mcpField
W
whatsapp-macos

whatsapp-macos

Local
github.com/kalki-kgpCommunication2Updated 10w ago

About whatsapp-macos

whatsapp-macos is a macOS MCP server that lets Claude read and search WhatsApp messages from the local database, with optional sending through a WhatsApp Web bridge. It is intended for people using WhatsApp Desktop who want chat history and unread messages available in an AI chat.

Key features

  1. 01Search contacts by name or number
  2. 02Read chat history with date filters
  3. 03List recent chats and unread counts
  4. 04Search messages across chats
  5. 05Summarize unread messages
  6. 06Send and receive messages through a bridge

Use cases

  1. 01Catch up on unread WhatsApp chats
  2. 02Find a past message by topic or date
  3. 03Look up recent conversations with a contact
  4. 04Send a reply after connecting the bridge

MCP support

Exposes WhatsApp status, contact, chat and message tools to MCP clients. Read operations query local SQLite databases; sending and incoming-message features require a bridge connected to WhatsApp Web.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

mcp.json · Universal config
{
"mcpServers": {
"kalki-kgp-whatsapp-macos": {
"command": "uvx",
"args": [
"whatsapp-mcp-macos"
]
}
}
}
Run commanduvx whatsapp-mcp-macos

Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.

Packages
pypiwhatsapp-mcp-macos0.1.1

Tools

No tool list yet

Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.

Details

From the project README

Check it out on https://mcp.paperknife.app/

WhatsApp MCP for macOS

A Model Context Protocol server that connects Claude to your WhatsApp. Ask Claude to catch you up on unread chats, search your message history, or send a reply.

Reading works in about a minute with no QR scan and no Node.js. Sending is optional and needs one extra step.

macOS MCP 1.0 MIT License

Features

Search contacts by name or phone number. Read chat history with date filtering. List recent conversations with unread counts. Summarize everything you haven't read yet. Send replies and receive incoming messages once the bridge is connected.

Requirements

  • macOS with the WhatsApp desktop app installed and logged in
  • Node.js 18+, only if you want to send messages

You don't need to install Python. uvx fetches a suitable version on its own.

Installation

Install uv if you don't have it:

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

That's the whole install. uvx downloads the server on first launch, so there's no virtualenv to create and no pip install step. Go to the next section to point Claude at it.

From source
git clone https://github.com/kalki-kgp/whatsapp-mcp.git
cd whatsapp-mcp
uv venv && uv pip install -e .

Connect to Claude Desktop

  1. Open config file:

    open ~/Library/Application\ Support/Claude/claude_desktop_config.json
    

    If it doesn't exist, create it.

  2. Find the full path to uvx:

    which uvx
    
  3. Add the WhatsApp MCP server, pasting that path as the command:

    {
      "mcpServers": {
        "whatsapp": {
          "command": "/Users/YOU/.local/bin/uvx",
          "args": ["whatsapp-mcp-macos"]
        }
      }
    }
    

    Use the absolute path, not bare uvx. Claude Desktop starts with a minimal PATH that doesn't include ~/.local/bin, so a bare command name is the most common reason the server never appears.

  4. Restart Claude Desktop with Cmd+Q, then reopen. Closing the window is not enough.

  5. Click the MCP tools icon in the chat input and check that "whatsapp" is listed.

  6. Start chatting:

    • "Show my recent WhatsApp chats"
    • "Search messages for dinner plans"

Connect to Cursor

Add to .cursor/mcp.json in your project:

{
  "mcpServers": {
    "whatsapp": {
      "command": "/Users/YOU/.local/bin/uvx",
      "args": ["whatsapp-mcp-macos"]
    }
  }
}

Restart Cursor and use WhatsApp tools in the AI chat.

Usage

Reading messages (works immediately)

Just ask Claude:

  • "Show my recent WhatsApp chats"
  • "Search for messages about dinner"
  • "What did John say yesterday?"
  • "Catch me up on unread messages"
Sending messages (requires bridge)
  1. Start the WhatsApp bridge:

    cd bridge && npm install && npm start
    
  2. Ask Claude to check connection:

    • "Check WhatsApp status"
  3. If it shows a QR code, open the data URL in a browser and scan with your phone

  4. Once connected, you can send:

    • "Send a message to Mom saying I'll be late"
    • "Reply to John with 'sounds good'"

Tools

ToolDescriptionRequires Bridge
whatsapp_statusCheck connection, get QR if neededNo
whatsapp_search_contactsSearch contacts by name/phoneNo
whatsapp_list_chatsList recent conversationsNo
whatsapp_get_messagesGet messages from a chatNo
whatsapp_search_messagesSearch across all chatsNo
whatsapp_unreadGet unread message summaryNo
whatsapp_sendSend a messageYes
whatsapp_incomingGet real-time incoming messagesYes

How it works

Claude ──MCP──▶ WhatsApp MCP Server
                       │
                       ├──▶ Local SQLite DBs (read messages)
                       │    ~/Library/Group Containers/group.net.whatsapp.WhatsApp.shared/
                       │
                       └──▶ WhatsApp Bridge (:3010) ──▶ WhatsApp Web
                            (for sending)

Read operations query the local WhatsApp database directly, so they work offline and need no bridge.

Send operations go through the bridge, which connects to WhatsApp Web using Baileys.

Development

# Clone
git clone https://github.com/kalki-kgp/whatsapp-mcp.git
cd whatsapp-mcp

# Install in dev mode
pip install -e ".[dev]"

# Run server
python -m whatsapp_mcp

Privacy

  • All data stays local. The server reads messages from your own WhatsApp database
  • No data is sent to external servers (except WhatsApp Web when sending)
  • The MCP server runs locally on your machine

License

MIT

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.