WhatsApp MCP Server

Instructions

Get a list of chats.

Parameters:
- limit: Maximum number of chats to return (default: 50)
- offset: Offset for pagination (default: 0)

Implementation Reference

• src/whatsapp_mcp/server.py:83-100 (handler)

  MCP tool handler and registration for get_chats via @mcp.tool() decorator. Checks authentication, fetches chats from helper module, and returns JSON response.

  @mcp.tool()
  async def get_chats(ctx: Context, limit: int = 50, offset: int = 0) -> str:
      """
      Get a list of chats.
  
      Parameters:
      - limit: Maximum number of chats to return (default: 50)
      - offset: Offset for pagination (default: 0)
      """
      try:
          if not auth.auth_manager.is_authenticated():
              return "Error: No active session"
  
          chats = await message.get_chats(limit=limit, offset=offset)
          return json.dumps({"chats": chats})
      except Exception as e:
          logger.error(f"Error getting chats: {e}")
          return f"Error: {str(e)}"

• src/whatsapp_mcp/models.py:15-20 (schema)

  Pydantic model defining the input schema for the get_chats tool, including limit and offset parameters.

  class GetChatsModel(BaseModel):
      """Input schema for get_chats tool."""
  
      limit: int = Field(50, description="Maximum number of chats to return")
      offset: int = Field(0, description="Offset for pagination")

• src/whatsapp_mcp/modules/message.py:68-117 (helper)

  Helper function implementing the core get_chats logic, retrieves WhatsApp client, applies pagination to mock chat data, and handles errors.

  async def get_chats(limit: int = 50, offset: int = 0) -> List[Dict[str, Any]]:
      """Get a list of chats."""
      logger.info("Getting chats for session")
  
      whatsapp_client = auth_manager.get_client()
      if not whatsapp_client:
          raise ValueError("Session not found")
  
      if not whatsapp_client.client:
          raise ValueError("WhatsApp client not initialized")
  
      try:
          # Note: This API might not directly support listing chats
          # Implement based on what the API supports
  
          # For APIs that don't support chat listing, we can implement a workaround:
          # 1. Store chat IDs in a local cache when messages are sent/received
          # 2. Return those cached chats here
  
          # In some WhatsApp API implementations, there may be a way to fetch conversations
          # Here we'll make a placeholder for when such API becomes available
  
          # If direct API not available, return mock data or cached data
          chats = [
              {
                  "id": "123456789@c.us",
                  "name": "John Doe",
                  "is_group": False,
                  "last_message": "Hello there!",
                  "timestamp": datetime.now().isoformat(),
              },
              {
                  "id": "987654321@g.us",
                  "name": "Family Group",
                  "is_group": True,
                  "participant_count": 5,
                  "last_message": "When are we meeting?",
                  "timestamp": datetime.now().isoformat(),
              },
          ]
  
          # Apply pagination
          start = offset
          end = offset + limit
  
          return chats[start:end]
  
      except Exception as e:
          logger.error(f"Failed to get chats: {e}")
          raise ValueError(f"Failed to get chats: {str(e)}")