# Feishu Bitable MCP

> Feishu Bitable MCP connects your AI agent directly to Lark's multi-dimensional table platform. It lets you manage complex databases, track records, and orchestrate data structures using only natural conversation. Instead of clicking through dozens of tabs, you simply tell your agent what you need—like listing all tables or updating specific fields—and get the result instantly.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** database-management, no-code, record-tracking, collaborative-data, schema-management

## Description

Managing a database shouldn't require navigating a web interface. With this MCP, your AI client treats Feishu Bitable like a conversational API. You can ask your agent to perform actions across multiple bases and tables without knowing where the data lives or how deep its structure goes. For example, you don't have to remember which table holds project status vs. resource allocation; you just tell your agent to get base information, and it finds what you need.

This capability means that whether you are tracking inventory, managing a client roster, or running operational reports, all data operations happen in plain language. Your agent handles the complexity—it can list fields, search through records with filters, batch create new entries, or even update existing information using `update_record`. It's like having an expert data administrator who lives inside your chat window. This kind of deep integration is what Vinkius makes possible, turning static databases into dynamic parts of your daily workflow.

## Tools

### create_records
Batch creates multiple new entries in a specified table with defined field values.

### delete_record
Permanently removes an identified record from the target table.

### get_base_info
Retrieves high-level metadata and structural information about an entire Bitable base.

### get_record_details
Fetches all the specific, detailed data points for a single record ID.

### list_fields
Lists every field available within a given table to confirm structure and names.

### list_records
Retrieves all records currently stored in a specific, non-filtered table view.

### list_tables
Lists every individual table that exists within the selected Bitable base app.

### list_views
Shows all defined virtual views for a table, helping you understand how data is segmented.

### search_records
Searches and returns records that match specific criteria or filter expressions across the dataset.

### update_record
Modifies one or more fields in an existing record using its unique ID.

## Prompt Examples

**Prompt:** 
```
List all tables in Bitable base 'AppbcbWCzen6D8dezhoCH2RpMAh'.
```

**Response:** 
```
I've retrieved the tables for the specified Bitable base. There are 3 tables: 'Inventory', 'Suppliers', and 'Orders'. Which one would you like to view records for?
```

**Prompt:** 
```
Add a new record to the 'Inventory' table with fields: Name='MacBook Pro', Quantity=5.
```

**Response:** 
```
Done! I've added the new record to the 'Inventory' table. The entry for 'MacBook Pro' with a quantity of 5 has been successfully created.
```

**Prompt:** 
```
Search for records in table 'tblsRc9GRRXKqhvW' where 'Status' equals 'Shipped'.
```

**Response:** 
```
I've performed the search and found 8 records matching your criteria. Would you like me to list their details or summarize the results?
```

## Capabilities

### Discovering Data Structures
You can ask the agent to list all available tables in a base and retrieve field schemas so you know exactly what data points exist.

### Querying and Finding Records
The agent searches records using custom filter expressions, allowing you to pinpoint specific entries across large datasets.

### Modifying Database Data
You can instruct the system to create new batches of records, update existing entries, or delete data directly through conversation.

## Use Cases

### Auditing Old Project Data
A project lead needs to know the status of all clients in a base created years ago. Instead of navigating through multiple views and running manual queries, they ask their agent to `list_tables` first, then use `search_records` across the correct table for records matching 'Status: Pending Review'. The agent returns only the relevant IDs.

### Onboarding New Team Members
An operations manager needs to ensure a new hire's data is correctly entered across several project tables. They prompt their agent, asking it to `create_records` for all standard fields in the 'Employee Info' table. The agent handles the required formatting and validation.

### Debugging Data Discrepancies
A data analyst spots a potential error. They use `get_record_details` on a suspicious record ID to pull all field values instantly, allowing them to compare it against the expected schema retrieved via `list_fields`.

### Quickly Updating Project Scope
A project manager has just received scope changes for 15 clients. Instead of opening 15 different records and manually changing fields, they instruct their agent to `update_record` for all relevant client IDs with the new scope details.

## Benefits

- Stop building complex filters. Instead of manually setting up advanced search criteria, just ask your agent to `search_records` for what you need, and it handles the syntax.
- Eliminate tedious data entry. You can tell your agent to `create_records` in a batch process, populating dozens of entries without ever leaving your chat window.
- Get full context instantly. Need to know which tables exist? Use `list_tables` first. The MCP gives you the structural overview before you try to read any data.
- Never lose track of schema changes again. If you're unsure what fields a table has, run `list_fields`. It provides an immediate audit of the structure.
- Audit and maintain consistency using `get_base_info` or `get_record_details`. You can confirm data integrity simply by asking your agent for details on specific bases.

## How It Works

The bottom line is: once connected, you use natural language prompts instead of complex UI navigation to manage your entire database setup.

1. First, subscribe to this MCP and enter your specific Feishu/Lark App ID and App Secret.
2. Next, connect the MCP to any compatible client—like Claude or Cursor. This establishes a secure connection between your agent and Bitable.
3. Finally, talk to your AI client naturally. Tell it what data you need, and your agent will run the necessary operations against your bases.

## Frequently Asked Questions

**How do I start using Feishu Bitable MCP to read my data?**
You first need to subscribe to the MCP and enter your App ID/Secret. Once connected, you can ask your agent to `list_tables` to see what bases are available.

**Can I bulk update records using Feishu Bitable MCP?**
Yes, you use the `update_record` tool. You provide a list of record IDs and the specific field/value changes, and your agent handles the batch modification.

**Is Feishu Bitable MCP only for reading data?**
No. While it excels at retrieval, it also allows you to write data back into Bitable using `create_records` or `update_record`, making it a full lifecycle tool.

**What if I need to find a record that doesn't fit simple filters?**
Use the `search_records` tool. It supports complex filter expressions, allowing you to search across multiple conditions simultaneously without needing to know the underlying query language.

**Does Feishu Bitable MCP help with data structure planning?**
Yes. You can use `list_fields` and `get_base_info` to audit your current schema, helping you confirm if all necessary fields exist before starting a project.