diff --git a/services/mounttable/mounttablelib/neighborhood_ble.go b/services/mounttable/mounttablelib/neighborhood_ble.go
new file mode 100644
index 0000000..478043d
--- /dev/null
+++ b/services/mounttable/mounttablelib/neighborhood_ble.go
@@ -0,0 +1,231 @@
+package mounttablelib
+
+import (
+	"strings"
+	"sync"
+	"time"
+
+	"v.io/v23/context"
+
+	"github.com/paypal/gatt"
+	"github.com/paypal/gatt/linux/cmd"
+)
+
+var mounttableServiceUUID = gatt.MustParseUUID("f7d47ad1-c344-4ad1-b43a-5be7570d3ffd")
+var addressesUUID = gatt.MustParseUUID("32719e70-5da5-4d40-9a4a-866f491b2f2d")
+
+func newMountTableService(addresses []string) *gatt.Service {
+	addressString := strings.Join(addresses, "@@@@")
+	s := gatt.NewService(mounttableServiceUUID)
+	s.AddCharacteristic(addressesUUID).HandleReadFunc(
+		func(rsp gatt.ResponseWriter, req *gatt.ReadRequest) {
+			if req.Offset > len(addressString) {
+				return
+			}
+			end := req.Offset + req.Cap
+			if end > len(addressString) {
+				end = len(addressString)
+			}
+			rsp.Write([]byte(addressString[req.Offset:end]))
+		})
+	return s
+}
+
+var (
+	attrGAPUUID = gatt.UUID16(0x1800)
+
+	attrDeviceNameUUID        = gatt.UUID16(0x2A00)
+	attrAppearanceUUID        = gatt.UUID16(0x2A01)
+	attrPeripheralPrivacyUUID = gatt.UUID16(0x2A02)
+	attrReconnectionAddrUUID  = gatt.UUID16(0x2A03)
+	attrPeferredParamsUUID    = gatt.UUID16(0x2A04)
+
+	attrGATTUUID           = gatt.UUID16(0x1801)
+	attrServiceChangedUUID = gatt.UUID16(0x2A05)
+)
+
+// https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.gap.appearance.xml
+var gapCharAppearanceGenericComputer = []byte{0x00, 0x80}
+
+func newGapService(name string) *gatt.Service {
+	s := gatt.NewService(attrGAPUUID)
+	s.AddCharacteristic(attrDeviceNameUUID).SetValue([]byte(name))
+	s.AddCharacteristic(attrAppearanceUUID).SetValue(gapCharAppearanceGenericComputer)
+	s.AddCharacteristic(attrPeripheralPrivacyUUID).SetValue([]byte{0x00})
+	s.AddCharacteristic(attrReconnectionAddrUUID).SetValue([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00})
+	s.AddCharacteristic(attrPeferredParamsUUID).SetValue([]byte{0x06, 0x00, 0x06, 0x00, 0x00, 0x00, 0xd0, 0x07})
+	return s
+}
+
+func newGattService() *gatt.Service {
+	s := gatt.NewService(attrGATTUUID)
+	s.AddCharacteristic(attrServiceChangedUUID).HandleNotifyFunc(
+		func(r gatt.Request, n gatt.Notifier) {})
+	return s
+}
+
+var gattServerOptions = []gatt.Option{
+	gatt.LnxMaxConnections(100),
+	gatt.LnxDeviceID(-1, true),
+	gatt.LnxSetAdvertisingParameters(&cmd.LESetAdvertisingParameters{
+		// Set an advertising rate of 150ms.  This value is multipled by
+		// 0.625ms to get the actual rate.
+		AdvertisingIntervalMin: 0x00f4,
+		AdvertisingIntervalMax: 0x00f4,
+		AdvertisingChannelMap:  0x7,
+	}),
+}
+
+type bleCacheEntry struct {
+	id        string
+	name      string
+	endpoints []string
+	lastSeen  time.Time
+}
+type bleNeighborHood struct {
+	mu                 sync.Mutex
+	neighborsIdCache   map[string]*bleCacheEntry
+	neighborsNameCache map[string]*bleCacheEntry
+	name               string
+	ctx                *context.T
+	serverDevice       gatt.Device
+	clientDevice       gatt.Device
+}
+
+func newBleNeighborhood(ctx *context.T, name string, eps []string) (*bleNeighborHood, error) {
+	b := &bleNeighborHood{
+		neighborsIdCache:   make(map[string]*bleCacheEntry),
+		neighborsNameCache: make(map[string]*bleCacheEntry),
+		name:               name,
+		ctx:                ctx,
+	}
+	return b, b.startBLEService(eps)
+}
+
+func (b *bleNeighborHood) startBLEService(eps []string) error {
+	d, err := gatt.NewDevice(gattServerOptions...)
+	if err != nil {
+		return err
+	}
+	d.Handle(
+		gatt.CentralConnected(func(c gatt.Central) { b.ctx.VI(0).Infof("Connect: %v", c.ID()) }),
+		gatt.CentralDisconnected(func(c gatt.Central) { b.ctx.VI(0).Infof("Disconnected: %v", c.ID()) }),
+	)
+
+	onStateChanged := func(d gatt.Device, s gatt.State) {
+		b.ctx.VI(0).Infof("State: %s", s)
+		switch s {
+		case gatt.StatePoweredOn:
+			d.AddService(newGapService(b.name))
+			d.AddService(newGattService())
+
+			s1 := newMountTableService(eps)
+			d.AddService(s1)
+			d.AdvertiseNameAndServices(b.name, []gatt.UUID{s1.UUID()})
+		default:
+		}
+	}
+
+	d.Init(onStateChanged)
+	b.serverDevice = d
+	return nil
+}
+
+var gattClientOptions = []gatt.Option{
+	gatt.LnxMaxConnections(1),
+	gatt.LnxDeviceID(-1, true),
+}
+
+func (b *bleNeighborHood) scanForNeighbors() {
+	onStateChanged := func(d gatt.Device, s gatt.State) {
+		switch s {
+		case gatt.StatePoweredOn:
+			// We should limit it to only mounttable service, but this
+			// isn't implemented in the library
+			d.Scan([]gatt.UUID{}, false)
+		default:
+			d.StopScanning()
+		}
+	}
+
+	onPeriphDiscovered := func(p gatt.Peripheral, a *gatt.Advertisement, rssi int) {
+		// TODO(bjornick): Handle error
+		p.Device().Connect(p)
+	}
+
+	onPeriphConnected := func(p gatt.Peripheral, err error) {
+		defer p.Device().CancelConnection(p)
+		if err := p.SetMTU(500); err != nil {
+			b.ctx.Errorf("Failed to set MTU, err: %s", err)
+			return
+		}
+
+		ss, err := p.DiscoverServices(nil)
+
+		if err != nil {
+			b.ctx.Errorf("Failed to discover services, err: %s", err)
+			return
+		}
+
+		for _, s := range ss {
+			if !s.UUID().Equal(mounttableServiceUUID) {
+				b.ctx.Infof("Skipping non-mt service %s", s.Name())
+				continue
+			}
+
+			cs, err := p.DiscoverCharacteristics(nil, s)
+			if err != nil {
+				b.ctx.Errorf("Failed to discover characteristics: %s", err)
+				continue
+			}
+
+			for _, c := range cs {
+				if !c.UUID().Equal(addressesUUID) {
+					b.ctx.Infof("Skipping non-address characteristic: %s", c.Name())
+					continue
+				}
+				eps, err := p.ReadCharacteristicBlob(c)
+				if err != nil {
+					b.ctx.Errorf("Failed to read the addresses: %v", err)
+					continue
+				}
+				b.saveAddress(p.ID(), p.Name(), string(eps))
+			}
+
+		}
+	}
+	var err error
+	b.clientDevice, err = gatt.NewDevice(gattClientOptions...)
+	if err != nil {
+		b.ctx.Errorf("Failed to open device, err: %s\n", err)
+		return
+	}
+	b.clientDevice.Handle(
+		gatt.PeripheralDiscovered(onPeriphDiscovered),
+		gatt.PeripheralConnected(onPeriphConnected),
+	)
+
+	b.clientDevice.Init(onStateChanged)
+}
+
+func (b *bleNeighborHood) saveAddress(id string, name string, eps string) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.ctx.VI(0).Infof("Saving endpoints (%s) for (%s, %s)", eps, id, name)
+	entry, found := b.neighborsIdCache[id]
+	if !found {
+		entry = &bleCacheEntry{
+			id:   id,
+			name: name,
+		}
+		b.neighborsIdCache[id] = entry
+		b.neighborsNameCache[name] = entry
+	}
+
+	if entry.name != name {
+		b.ctx.Errorf("Name of the neighbor changed. was %s, now %s", entry.name, name)
+		return
+	}
+	entry.endpoints = strings.Split(eps, "@@@")
+	entry.lastSeen = time.Now()
+}
diff --git a/services/mounttable/mounttablelib/servers.go b/services/mounttable/mounttablelib/servers.go
index 2d919d1..3e9a295 100644
--- a/services/mounttable/mounttablelib/servers.go
+++ b/services/mounttable/mounttablelib/servers.go
@@ -67,6 +67,12 @@
 			return "", nil, err
 		}
 		stopFuncs = append(stopFuncs, nhServer.Stop)
+
+		// For now let's leak this server.  This is for ble support
+		_, err = newBleNeighborhood(ctx, nhName[0], mtServer.ServerStatus().Endpoints())
+		if err != nil {
+			return "", nil, err
+		}
 	}
 	return mtName, stop, nil
 }