diff --git a/pkg/nbi/common.go b/pkg/nbi/common.go
new file mode 100644
index 0000000..4f80e8c
--- /dev/null
+++ b/pkg/nbi/common.go
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Package nbi holds rpc server apis implemented
+package nbi
+
+import (
+	"context"
+	"net"
+	"os"
+
+	"github.com/opencord/opendevice-manager/pkg/config"
+
+	"github.com/opencord/device-management-interface/go/dmi"
+
+	"github.com/opencord/voltha-lib-go/v4/pkg/log"
+	g "google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/reflection"
+)
+
+// logger represents the log object
+var logger log.CLogger
+
+// grpcServer refers to object which holds grpc serevr
+var grpcServer *g.Server
+
+// init function for the package
+func init() {
+	logger = config.Initlog()
+	initConnectMap()
+}
+
+func registerServers(grpcServer *g.Server) {
+	hwMgmtSvc := new(NativeHwManagementService)
+	dmi.RegisterNativeHWManagementServiceServer(grpcServer, hwMgmtSvc)
+	reflection.Register(grpcServer)
+}
+
+// StartGrpcServer starts the grpc server for listening to NEM requests
+func StartGrpcServer(ctx context.Context) {
+	coreFlags := config.GetCoreFlags()
+	lis, err := net.Listen("tcp", coreFlags.GrpcEndPoint)
+	if err != nil {
+		logger.Error(ctx, "Failed-to-listen-on-Grpc-Port", log.Fields{"grpc-flags": coreFlags.GrpcFlags, "error": err})
+		os.Exit(1)
+	}
+
+	if coreFlags.SecureConnection {
+		creds, err := credentials.NewServerTLSFromFile(coreFlags.ServerCrt, coreFlags.ServerKey)
+		if err != nil {
+			logger.Error(ctx, "could-not-process-the-credentials", log.Fields{"error": err})
+		}
+		grpcServer = g.NewServer(g.Creds(creds))
+	} else {
+		grpcServer = g.NewServer()
+	}
+
+	registerServers(grpcServer)
+
+	logger.Infow(ctx, "Grpc-server-starting", log.Fields{"grpc-server-info": grpcServer, "grpc-env-info": coreFlags.GrpcFlags, "is-secure-conn": coreFlags.SecureConnection})
+
+	// Starting the server
+	if err := grpcServer.Serve(lis); err != nil {
+		logger.Errorw(ctx, "Failed-to-start-Grpc-Server", log.Fields{"server": coreFlags.GrpcFlags, "error": err})
+		os.Exit(1)
+	}
+
+	logger.Infow(ctx, "grpc-server-stopped-successfully", log.Fields{"grpc-server-info": grpcServer, "grpc-env-info": coreFlags.GrpcFlags})
+
+}
+
+// StopGrpcServer tear down the gRPC connection from opendevice manager to NEM
+func StopGrpcServer(ctx context.Context) {
+	if grpcServer != nil {
+		grpcServer.GracefulStop()
+	}
+	logger.Infow(ctx, "grpc-server-teardown-success", log.Fields{"grpc-server-info": grpcServer})
+}
diff --git a/pkg/nbi/connection.go b/pkg/nbi/connection.go
new file mode 100644
index 0000000..ae94999
--- /dev/null
+++ b/pkg/nbi/connection.go
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Package nbi holds rpc server apis implemented
+package nbi
+
+import (
+	"context"
+	"sync"
+
+	dev "github.com/opencord/opendevice-manager/pkg/models/device"
+	"github.com/opencord/opendevice-manager/pkg/sbi"
+	"github.com/opencord/voltha-lib-go/v4/pkg/log"
+)
+
+// connectMap store all device connections established
+type connectMap struct {
+	nameToAdapter map[string]sbi.Adapter // key is name and value is adapter
+	mutex         *sync.RWMutex          // mutex is used to lock when accessing
+}
+
+var connections *connectMap
+
+// initConnectMap initialises map for storing connections
+func initConnectMap() {
+	connections = new(connectMap)
+	connections.nameToAdapter = make(map[string]sbi.Adapter)
+	connections.mutex = &sync.RWMutex{}
+}
+
+// DeInitConnectMap clears all stored connections
+func DeInitConnectMap(ctx context.Context) {
+	connections.nameToAdapter = nil
+	connections.mutex = nil
+	connections = nil
+}
+
+// getConnection retrieves connection object from map using name
+func (conn *connectMap) getConnection(ctx context.Context, devRec *dev.DeviceRecord) (sbi.Adapter, error) {
+	conn.mutex.Lock()
+	defer conn.mutex.Unlock()
+	if val, ok := conn.nameToAdapter[devRec.Name]; ok {
+		return val, nil
+	}
+
+	// Get the right adapter
+	adapter := sbi.GetHwMgmtSvcClient(devRec)
+	if err := adapter.Connect(ctx); err != nil {
+		return nil, err
+	}
+
+	conn.nameToAdapter[devRec.Name] = adapter
+	logger.Infow(ctx, "getConnection-completed", log.Fields{"name": devRec.Name, "adapter": adapter})
+
+	return adapter, nil
+}
+
+// // storeConn stores connection object in map using uuid and name
+// func (conn *connectMap) storeConnWithName(ctx context.Context, name string, adapter sbi.Adapter) {
+// 	conn.mutex.Lock()
+// 	defer conn.mutex.Unlock()
+// 	conn.nameToAdapter[name] = adapter
+// 	logger.Infow(ctx, "storeConnWithName-completed", log.Fields{"name": name, "adapter": adapter})
+// }
+
+// delConn deletes connection object from map using uuid and name
+func (conn *connectMap) delConn(ctx context.Context, name string) {
+	conn.mutex.Lock()
+	defer conn.mutex.Unlock()
+
+	if name != "" {
+		delete(conn.nameToAdapter, name)
+	}
+	logger.Infow(ctx, "delConn-completed", log.Fields{"name": name})
+}
diff --git a/pkg/nbi/hw_mgmt_svc_api.go b/pkg/nbi/hw_mgmt_svc_api.go
new file mode 100644
index 0000000..0bfd82f
--- /dev/null
+++ b/pkg/nbi/hw_mgmt_svc_api.go
@@ -0,0 +1,388 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Package nbi holds rpc server apis implemented
+package nbi
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jinzhu/copier"
+	"github.com/opencord/device-management-interface/go/dmi"
+	"github.com/opencord/opendevice-manager/pkg/config"
+	"github.com/opencord/voltha-lib-go/v4/pkg/log"
+
+	dev "github.com/opencord/opendevice-manager/pkg/models/device"
+	hw "github.com/opencord/opendevice-manager/pkg/models/hwcomponents"
+
+	empty "github.com/golang/protobuf/ptypes/empty"
+)
+
+// StartManagingDevice refers to the RPC method invoked for start Managing Device.
+// Initializes context for a device and sets up required states
+func (c *NativeHwManagementService) StartManagingDevice(req *dmi.ModifiableComponent, streamResp dmi.NativeHWManagementService_StartManagingDeviceServer) error {
+	ctx := config.GetNewContextFromGlobalContxt("StartManagingDevice")
+
+	logger.Infow(ctx, "StartManagingDevice-invoked-on-grpc-server", log.Fields{"req": req})
+	defer logger.Infow(ctx, "StartManagingDevice-on-grpc-server-completed", log.Fields{"req": req})
+
+	if errorResp, ok := validateStartManagingDeviceReq(ctx, req); !ok {
+		streamResp.Send(errorResp)
+		return errors.New("failed at validateStartManagingDeviceReq")
+	}
+
+	devRec, err := dev.NewDeviceRecord(ctx, req)
+
+	if err != nil {
+		streamResp.Send(errRespStartManagingDevice(ctx, req, dmi.StartManagingDeviceResponse_INVALID_PARAMS, err))
+		return err
+	}
+
+	adapter, err := connections.getConnection(ctx, devRec)
+
+	if adapter == nil {
+		streamResp.Send(errRespStartManagingDevice(ctx, req, dmi.StartManagingDeviceResponse_INVALID_PARAMS, err))
+		return err
+	}
+
+	devRec.DBAddByName(ctx)
+
+	err, connMade := adapter.StartManagingDevice(ctx, devRec, req, streamResp)
+
+	if !connMade {
+		devRec.DBDelRecord(ctx)
+		adapter.Disconnect(ctx)
+		connections.delConn(ctx, devRec.Name)
+		streamResp.Send(errRespStartManagingDevice(ctx, req, dmi.StartManagingDeviceResponse_UNDEFINED_REASON, err))
+	}
+
+	return err
+}
+
+// StopManagingDevice - Stops management of a device and clean up any context and caches for that device
+// This rpc can be called at any time, even before the StartManagingDevice operation
+// has completed, and should be able to cleanup.
+func (c *NativeHwManagementService) StopManagingDevice(ctx context.Context, req *dmi.StopManagingDeviceRequest) (*dmi.StopManagingDeviceResponse, error) {
+
+	var devRec *dev.DeviceRecord
+	resp := new(dmi.StopManagingDeviceResponse)
+	var err error
+
+	ctx = config.GetNewContextFromContxt(ctx, "StopManagingDevice")
+
+	logger.Infow(ctx, "StopManagingDevice-invoked-on-grpc-server", log.Fields{"req": req})
+	defer logger.Infow(ctx, "StopManagingDevice-on-grpc-server-completed", log.Fields{"req": req})
+
+	if recTmp, err := dev.DBGetByName(ctx, req.Name); recTmp == nil {
+		return errRespStopManagingDevice(ctx, req, dmi.StopManagingDeviceResponse_UNKNOWN_DEVICE, err), err
+	} else {
+		devRec = recTmp
+	}
+
+	defer devRec.DBDelRecord(ctx)
+	defer hw.DBDelAllHwComponents(ctx, devRec.Uuid)
+
+	adapter, err := connections.getConnection(ctx, devRec)
+
+	if adapter != nil {
+		resp, err = adapter.StopManagingDevice(ctx, devRec, req)
+		adapter.Disconnect(ctx)
+		connections.delConn(ctx, devRec.Name)
+	}
+
+	if err != nil {
+		logger.Errorw(ctx, "Errors-at-StopManagingDevice", log.Fields{"req": req, "error": err})
+	}
+
+	return resp, err
+}
+
+// GetManagedDevices - Returns an object containing a list of devices managed by this entity
+func (c *NativeHwManagementService) GetManagedDevices(ctx context.Context, req *empty.Empty) (*dmi.ManagedDevicesResponse, error) {
+	ctx = config.GetNewContextFromContxt(ctx, "GetManagedDevices")
+	resp := new(dmi.ManagedDevicesResponse)
+
+	logger.Infow(ctx, "GetManagedDevices-invoked-on-grpc-server", log.Fields{"req": req})
+	defer logger.Infow(ctx, "GetManagedDevices-on-grpc-server-completed", log.Fields{"req": req})
+
+	listDevRecs, err := dev.DBGetAll(ctx)
+	for _, devRec := range listDevRecs {
+		modComp := new(dmi.ModifiableComponent)
+		err2 := copier.Copy(&modComp, &devRec)
+		if err2 != nil {
+			logger.Errorw(ctx, "Copy-failed-at-GetManagedDevices", log.Fields{"req": req, "rec": devRec, "error": err})
+		} else {
+			modComp.Uri.Uri = devRec.Uri
+			resp.Devices = append(resp.Devices, modComp)
+		}
+	}
+	logger.Infow(ctx, "GetManagedDevices-completed", log.Fields{"req": req, "resp": resp, "error": err})
+	return resp, err
+}
+
+// GetPhysicalInventory - Place Holder for implementation in future
+func (c *NativeHwManagementService) GetPhysicalInventory(req *dmi.PhysicalInventoryRequest, streamResp dmi.NativeHWManagementService_GetPhysicalInventoryServer) error {
+
+	ctx := config.GetNewContextFromGlobalContxt("GetPhysicalInventory")
+
+	logger.Infow(ctx, "GetPhysicalInventory-invoked-on-grpc-server", log.Fields{"req": req})
+	defer logger.Infow(ctx, "GetPhysicalInventory-on-grpc-server-completed", log.Fields{"req": req})
+
+	var devRec *dev.DeviceRecord
+
+	if recTmp, err := dev.DBGetByUuid(ctx, req.DeviceUuid.Uuid); recTmp == nil {
+		streamResp.Send(errRespGetPhysicatInventory(ctx, req, dmi.PhysicalInventoryResponse_UNKNOWN_DEVICE, err))
+		return err
+	} else {
+		devRec = recTmp
+	}
+
+	adapter, err := connections.getConnection(ctx, devRec)
+	if adapter == nil {
+		streamResp.Send(errRespGetPhysicatInventory(ctx, req, dmi.PhysicalInventoryResponse_DEVICE_UNREACHABLE, err))
+		return err
+	}
+
+	err = adapter.GetPhysicalInventory(ctx, devRec, req, streamResp)
+
+	if err != nil {
+		logger.Errorw(ctx, "Errors-at-GetPhysicalInventory", log.Fields{"req": req, "error": err})
+	}
+
+	return err
+}
+
+// GetHWComponentInfo - refers to the RPC method invoked for get the details of a particular HW component
+func (c *NativeHwManagementService) GetHWComponentInfo(req *dmi.HWComponentInfoGetRequest, streamResp dmi.NativeHWManagementService_GetHWComponentInfoServer) error {
+	ctx := config.GetNewContextFromGlobalContxt("GetHWComponentInfo")
+
+	logger.Infow(ctx, "GetHWComponentInfo-invoked-on-grpc-server", log.Fields{"req": req})
+	defer logger.Infow(ctx, "GetHWComponentInfo-on-grpc-server-completed", log.Fields{"req": req})
+
+	devRec, err := dev.DBGetByUuid(ctx, req.DeviceUuid.Uuid)
+	if devRec == nil {
+		streamResp.Send(errRespGetHWComponentInfo(ctx, req, dmi.HWComponentInfoGetResponse_UNKNOWN_DEVICE, err))
+		return err
+	}
+
+	hwCompRec, err := hw.DBGetRecByUuid(ctx, req.DeviceUuid.Uuid, req.ComponentUuid.Uuid)
+	if hwCompRec == nil {
+		streamResp.Send(errRespGetHWComponentInfo(ctx, req, dmi.HWComponentInfoGetResponse_UNKNOWN_DEVICE, err))
+		return err
+	}
+
+	adapter, err := connections.getConnection(ctx, devRec)
+	if adapter == nil {
+		streamResp.Send(errRespGetHWComponentInfo(ctx, req, dmi.HWComponentInfoGetResponse_DEVICE_UNREACHABLE, err))
+		return err
+	}
+
+	err = adapter.GetHWComponentInfo(ctx, devRec.Uuid, hwCompRec, req, streamResp)
+	if err != nil {
+		logger.Errorw(ctx, "Errors-at-GetHWComponentInfo", log.Fields{"req": req, "error": err})
+	}
+	return err
+}
+
+// SetHWComponentInfo is the nb api exposed for receiving SetHWComponentInfo from NEM
+func (c *NativeHwManagementService) SetHWComponentInfo(ctx context.Context, req *dmi.HWComponentInfoSetRequest) (*dmi.HWComponentInfoSetResponse, error) {
+	ctx = config.GetNewContextFromContxt(ctx, "SetHWComponentInfo")
+
+	logger.Infow(ctx, "SetHWComponentInfo-invoked-on-grpc-server", log.Fields{"req": req})
+	defer logger.Infow(ctx, "SetHWComponentInfo-on-grpc-server-completed", log.Fields{"req": req})
+
+	var devRec *dev.DeviceRecord
+	var hwCompRec *hw.HwCompRecord
+	var err error
+
+	if devRec, err = dev.DBGetByUuid(ctx, req.DeviceUuid.Uuid); devRec == nil {
+		return errRespSetHWComponentInfo(ctx, req, dmi.HWComponentInfoSetResponse_UNKNOWN_DEVICE, err), err
+	}
+
+	if hwCompRec, err = hw.DBGetRecByUuid(ctx, req.DeviceUuid.Uuid, req.ComponentUuid.Uuid); hwCompRec == nil {
+		return errRespSetHWComponentInfo(ctx, req, dmi.HWComponentInfoSetResponse_UNKNOWN_DEVICE, err), err
+	}
+
+	adapter, err := connections.getConnection(ctx, devRec)
+	if adapter == nil {
+		return errRespSetHWComponentInfo(ctx, req, dmi.HWComponentInfoSetResponse_DEVICE_UNREACHABLE, err), err
+	}
+
+	resp, err := adapter.SetHWComponentInfo(ctx, devRec.Uuid, hwCompRec, req)
+
+	if err != nil {
+		logger.Errorw(ctx, "Errors-at-SetHWComponentInfo", log.Fields{"req": req, "error": err})
+	}
+
+	return resp, err
+}
+
+// SetLoggingEndpoint - refers to the RPC method invoked for set the location to which logs need to be shipped
+func (c *NativeHwManagementService) SetLoggingEndpoint(ctx context.Context, req *dmi.SetLoggingEndpointRequest) (*dmi.SetRemoteEndpointResponse, error) {
+	ctx = config.GetNewContextFromGlobalContxt("SetLoggingEndpoint")
+
+	logger.Infow(ctx, "SetLoggingEndpoint-invoked-on-grpc-server", log.Fields{"req": req})
+	defer logger.Infow(ctx, "SetLoggingEndpoint-on-grpc-server-completed", log.Fields{"req": req})
+
+	// Check device is there or not by Uuid
+	devRec, err := dev.DBGetByUuid(ctx, req.DeviceUuid.Uuid)
+	if err != nil {
+		return errRespSetLoggingEndpoint(ctx, req, dmi.SetRemoteEndpointResponse_UNKNOWN_DEVICE, err), err
+	}
+
+	adapter, err2 := connections.getConnection(ctx, devRec)
+	if adapter == nil {
+		return errRespSetLoggingEndpoint(ctx, req, dmi.SetRemoteEndpointResponse_DEVICE_UNREACHABLE, err2), err2
+	}
+
+	resp, err := adapter.SetLoggingEndpoint(ctx, devRec, req)
+	if err != nil {
+		logger.Errorw(ctx, "Errors-at-SetLoggingEndpoint", log.Fields{"req": req, "error": err})
+	}
+
+	return resp, err
+}
+
+// GetLoggingEndpoint - refers to the RPC method invoked for get the location to which logs need to be shipped
+func (c *NativeHwManagementService) GetLoggingEndpoint(ctx context.Context, req *dmi.HardwareID) (*dmi.GetLoggingEndpointResponse, error) {
+	ctx = config.GetNewContextFromGlobalContxt("GetLoggingEndpoint")
+
+	logger.Infow(ctx, "GetLoggingEndpoint-invoked-on-grpc-server", log.Fields{"req": req})
+	defer logger.Infow(ctx, "GetLoggingEndpoint-on-grpc-server-completed", log.Fields{"req": req})
+
+	// Check device is there or not by Uuid
+	devRec, err := dev.DBGetByUuid(ctx, req.Uuid.Uuid)
+	if err != nil {
+		return errRespGetLoggingEndpoint(ctx, req, dmi.GetLoggingEndpointResponse_UNKNOWN_DEVICE, err), err
+	}
+
+	adapter, err := connections.getConnection(ctx, devRec)
+	if adapter == nil {
+		return errRespGetLoggingEndpoint(ctx, req, dmi.GetLoggingEndpointResponse_DEVICE_UNREACHABLE, err), err
+	}
+
+	resp, err := adapter.GetLoggingEndpoint(ctx, devRec, req)
+	if err != nil {
+		logger.Errorw(ctx, "Errors-at-GetLoggingEndpoint", log.Fields{"req": req, "error": err})
+	}
+	return resp, err
+}
+
+// SetMsgBusEndpoint - Place Holder for implementation in future
+func (c *NativeHwManagementService) SetMsgBusEndpoint(ctx context.Context, req *dmi.SetMsgBusEndpointRequest) (*dmi.SetRemoteEndpointResponse, error) {
+	errMsg := "SetMsgBusEndpoint not yet implemented"
+	fmt.Println(errMsg)
+	return nil, errors.New(errMsg)
+}
+
+// GetMsgBusEndpoint - Place Holder for implementation in future
+func (c *NativeHwManagementService) GetMsgBusEndpoint(ctx context.Context, req *empty.Empty) (*dmi.GetMsgBusEndpointResponse, error) {
+	errMsg := "GetMsgBusEndpoint not yet implemented"
+	fmt.Println(errMsg)
+	return nil, errors.New(errMsg)
+}
+
+// GetLoggableEntities refers to the grpc northbound interface exposed for getting loggable entities from device
+func (c *NativeHwManagementService) GetLoggableEntities(ctx context.Context, req *dmi.GetLoggableEntitiesRequest) (*dmi.GetLogLevelResponse, error) {
+
+	ctx = config.GetNewContextFromContxt(ctx, "GetLoggableEntities")
+	resp := new(dmi.GetLogLevelResponse)
+	resp.DeviceUuid = req.DeviceUuid
+
+	logger.Infow(ctx, "GetLoggableEntities-invoked-on-grpc-server", log.Fields{"req": req})
+	defer logger.Infow(ctx, "GetLoggableEntities-on-grpc-server-completed", log.Fields{"req": req})
+
+	devRec, err := dev.DBGetByUuid(ctx, req.DeviceUuid.Uuid)
+	if err != nil {
+		return errRespGetLoggableEntities(ctx, req, dmi.GetLogLevelResponse_UNKNOWN_DEVICE, err), err
+	}
+
+	if devRec.Logging.LoggableEntities != nil {
+		resp.Status = dmi.Status_OK_STATUS
+		resp.LogLevels, _ = devRec.GetLoggableEntitiesFromDevRec(ctx, nil)
+		return resp, nil
+	}
+
+	adapter, err := connections.getConnection(ctx, devRec)
+	if adapter == nil {
+		return errRespGetLoggableEntities(ctx, req, dmi.GetLogLevelResponse_DEVICE_UNREACHABLE, err), err
+	}
+
+	return adapter.GetLoggableEntities(ctx, devRec, req)
+}
+
+// SetLogLevel refers to the grpc northbound interface exposed for setting log level for entities
+func (c *NativeHwManagementService) SetLogLevel(ctx context.Context, req *dmi.SetLogLevelRequest) (*dmi.SetLogLevelResponse, error) {
+
+	ctx = config.GetNewContextFromContxt(ctx, "SetLogLevel")
+	resp := new(dmi.SetLogLevelResponse)
+	resp.DeviceUuid = req.DeviceUuid
+
+	logger.Infow(ctx, "SetLogLevel-invoked-on-grpc-server", log.Fields{"req": req})
+	defer logger.Infow(ctx, "SetLogLevel-on-grpc-server-completed", log.Fields{"req": req})
+
+	// validate request
+	if ok, err := isValidSetLogLevel(ctx, req.Loglevels); ok {
+		return errRespSetLogLevel(ctx, req, dmi.SetLogLevelResponse_UNKNOWN_LOG_ENTITY, err), err
+	}
+
+	devRec, err := dev.DBGetByUuid(ctx, req.DeviceUuid.Uuid)
+	if err != nil {
+		return errRespSetLogLevel(ctx, req, dmi.SetLogLevelResponse_UNKNOWN_DEVICE, err), err
+	}
+
+	adapter, err := connections.getConnection(ctx, devRec)
+	if adapter == nil {
+		return errRespSetLogLevel(ctx, req, dmi.SetLogLevelResponse_DEVICE_UNREACHABLE, err), err
+	}
+
+	return adapter.SetLogLevel(ctx, devRec, req)
+}
+
+// GetLogLevel refers to the grpc northbound interface exposed for getting log level of entities
+func (c *NativeHwManagementService) GetLogLevel(ctx context.Context, req *dmi.GetLogLevelRequest) (*dmi.GetLogLevelResponse, error) {
+
+	ctx = config.GetNewContextFromContxt(ctx, "GetLogLevel")
+	resp := new(dmi.GetLogLevelResponse)
+	resp.DeviceUuid = req.DeviceUuid
+
+	logger.Infow(ctx, "GetLogLevel-invoked-on-grpc-server", log.Fields{"req": req})
+	defer logger.Infow(ctx, "GetLogLevel-on-grpc-server-completed", log.Fields{"req": req})
+
+	devRec, err := dev.DBGetByUuid(ctx, req.DeviceUuid.Uuid)
+	if err != nil {
+		return errRespGetLogLevel(ctx, req, dmi.GetLogLevelResponse_UNKNOWN_DEVICE, err), err
+	}
+
+	if devRec.Logging.LoggableEntities != nil {
+
+		if output, ok := devRec.GetLoggableEntitiesFromDevRec(ctx, req.Entities); ok {
+			resp.Status = dmi.Status_OK_STATUS
+			resp.LogLevels = output
+			return resp, nil
+		}
+
+	}
+
+	adapter, err := connections.getConnection(ctx, devRec)
+	if adapter == nil {
+		return errRespGetLogLevel(ctx, req, dmi.GetLogLevelResponse_DEVICE_UNREACHABLE, err), err
+	}
+
+	return adapter.GetLogLevel(ctx, devRec, req)
+}
diff --git a/pkg/nbi/hw_mgmt_svc_err_resp.go b/pkg/nbi/hw_mgmt_svc_err_resp.go
new file mode 100644
index 0000000..ab0c517
--- /dev/null
+++ b/pkg/nbi/hw_mgmt_svc_err_resp.go
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Package nbi holds rpc server apis implemented
+package nbi
+
+import (
+	"context"
+
+	"github.com/opencord/device-management-interface/go/dmi"
+	"github.com/opencord/voltha-lib-go/v4/pkg/log"
+)
+
+// errRespStartManagingDevice represents the func to construct error response for rpc StartManagingDevice
+func errRespStartManagingDevice(ctx context.Context, req *dmi.ModifiableComponent, reason dmi.StartManagingDeviceResponse_Reason, err error) *dmi.StartManagingDeviceResponse {
+	resp := new(dmi.StartManagingDeviceResponse)
+	resp.Status = dmi.Status_ERROR_STATUS
+	resp.Reason = reason
+	resp.ReasonDetail = err.Error()
+	logger.Errorw(ctx, "StartManagingDevice-on-grpc-server-failed", log.Fields{"req": req, "resp": resp, "error": err})
+	return resp
+}
+
+// errRespStopManagingDevice represents the func to construct error response for rpc StopManagingDevice
+func errRespStopManagingDevice(ctx context.Context, req *dmi.StopManagingDeviceRequest, reason dmi.StopManagingDeviceResponse_Reason, err error) *dmi.StopManagingDeviceResponse {
+	resp := new(dmi.StopManagingDeviceResponse)
+	resp.Status = dmi.Status_ERROR_STATUS
+	resp.Reason = reason
+	resp.ReasonDetail = err.Error()
+	logger.Errorw(ctx, "StopManagingDevice-on-grpc-server-failed", log.Fields{"req": req, "resp": resp, "error": err})
+	return resp
+}
+
+// errRespGetPhysicatInventory represents the func to construct error response for rpc GetPhysicatInventory
+func errRespGetPhysicatInventory(ctx context.Context, req *dmi.PhysicalInventoryRequest, reason dmi.PhysicalInventoryResponse_Reason, err error) *dmi.PhysicalInventoryResponse {
+	resp := new(dmi.PhysicalInventoryResponse)
+	resp.Status = dmi.Status_ERROR_STATUS
+	resp.Reason = reason
+	resp.ReasonDetail = err.Error()
+	logger.Errorw(ctx, "GetPhysicatInventory-on-grpc-server-failed", log.Fields{"req": req, "resp": resp, "error": err})
+	return resp
+}
+
+// errRespGetHWComponentInfo represents the func to construct error response for rpc GetHWComponentInfo
+func errRespGetHWComponentInfo(ctx context.Context, req *dmi.HWComponentInfoGetRequest, reason dmi.HWComponentInfoGetResponse_Reason, err error) *dmi.HWComponentInfoGetResponse {
+	resp := new(dmi.HWComponentInfoGetResponse)
+	resp.Status = dmi.Status_ERROR_STATUS
+	resp.Reason = reason
+	resp.ReasonDetail = err.Error()
+	logger.Errorw(ctx, "GetHWComponentInfo-on-grpc-server-failed", log.Fields{"req": req, "resp": resp, "error": err})
+	return resp
+}
+
+// errRespSetHWComponentInfo represents the func to construct error response for rpc SetHWComponentInfo
+func errRespSetHWComponentInfo(ctx context.Context, req *dmi.HWComponentInfoSetRequest, reason dmi.HWComponentInfoSetResponse_Reason, err error) *dmi.HWComponentInfoSetResponse {
+	resp := new(dmi.HWComponentInfoSetResponse)
+	resp.Status = dmi.Status_ERROR_STATUS
+	resp.Reason = reason
+	resp.ReasonDetail = err.Error()
+	logger.Errorw(ctx, "SetHWComponentInfo-on-grpc-server-failed", log.Fields{"req": req, "resp": resp, "error": err})
+	return resp
+}
+
+// errRespSetLoggingEndpoint represents the func to construct error response for rpc SetLoggingEndpoint
+func errRespSetLoggingEndpoint(ctx context.Context, req *dmi.SetLoggingEndpointRequest, reason dmi.SetRemoteEndpointResponse_Reason, err error) *dmi.SetRemoteEndpointResponse {
+	resp := new(dmi.SetRemoteEndpointResponse)
+	resp.Status = dmi.Status_ERROR_STATUS
+	resp.Reason = reason
+	resp.ReasonDetail = err.Error()
+	logger.Errorw(ctx, "SetLoggingEndpoint-on-grpc-server-failed", log.Fields{"req": req, "resp": resp, "error": err})
+	return resp
+}
+
+// errRespGetLoggingEndpoint represents the func to construct error response for rpc GetLoggingEndpoint
+func errRespGetLoggingEndpoint(ctx context.Context, req *dmi.HardwareID, reason dmi.GetLoggingEndpointResponse_Reason, err error) *dmi.GetLoggingEndpointResponse {
+	resp := new(dmi.GetLoggingEndpointResponse)
+	resp.Status = dmi.Status_ERROR_STATUS
+	resp.Reason = reason
+	resp.ReasonDetail = err.Error()
+	logger.Errorw(ctx, "GetLoggingEndpoint-on-grpc-server-failed", log.Fields{"req": req, "resp": resp, "error": err})
+	return resp
+}
+
+// errRespGetLoggableEntities represents the func to construct error response for rpc GetLoggableEntities
+func errRespGetLoggableEntities(ctx context.Context, req *dmi.GetLoggableEntitiesRequest, reason dmi.GetLogLevelResponse_Reason, err error) *dmi.GetLogLevelResponse {
+	resp := new(dmi.GetLogLevelResponse)
+	resp.DeviceUuid = req.DeviceUuid
+	resp.Status = dmi.Status_ERROR_STATUS
+	resp.Reason = reason
+	resp.ReasonDetail = err.Error()
+	logger.Errorw(ctx, "GetLoggableEntities-on-grpc-server-failed", log.Fields{"req": req, "resp": resp, "error": err})
+	return resp
+}
+
+// errRespSetLogLevel represents the func to construct error response for rpc SetLogLevel
+func errRespSetLogLevel(ctx context.Context, req *dmi.SetLogLevelRequest, reason dmi.SetLogLevelResponse_Reason, err error) *dmi.SetLogLevelResponse {
+	resp := new(dmi.SetLogLevelResponse)
+	resp.DeviceUuid = req.DeviceUuid
+	resp.Status = dmi.Status_ERROR_STATUS
+	resp.Reason = reason
+	resp.ReasonDetail = err.Error()
+	logger.Errorw(ctx, "SetLogLevel-on-grpc-server-failed", log.Fields{"req": req, "resp": resp, "error": err})
+	return resp
+}
+
+// errRespGetLogLevel represents the func to construct error response for rpc GetLogLevel
+func errRespGetLogLevel(ctx context.Context, req *dmi.GetLogLevelRequest, reason dmi.GetLogLevelResponse_Reason, err error) *dmi.GetLogLevelResponse {
+	resp := new(dmi.GetLogLevelResponse)
+	resp.DeviceUuid = req.DeviceUuid
+	resp.Status = dmi.Status_ERROR_STATUS
+	resp.Reason = reason
+	resp.ReasonDetail = err.Error()
+	logger.Errorw(ctx, "GetLogLevel-on-grpc-server-failed", log.Fields{"req": req, "resp": resp, "error": err})
+	return resp
+}
diff --git a/pkg/nbi/server_structs.go b/pkg/nbi/server_structs.go
new file mode 100644
index 0000000..8811397
--- /dev/null
+++ b/pkg/nbi/server_structs.go
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Package nbi holds rpc server apis implemented
+package nbi
+
+// NativeHwManagementService refers to the struct defined for Service NativeHwManagementService
+type NativeHwManagementService struct {
+}
diff --git a/pkg/nbi/util.go b/pkg/nbi/util.go
new file mode 100644
index 0000000..d8af7cc
--- /dev/null
+++ b/pkg/nbi/util.go
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Package nbi holds rpc server apis implemented
+package nbi
+
+import (
+	"context"
+	"errors"
+	"net"
+	"strconv"
+	"strings"
+
+	"github.com/opencord/device-management-interface/go/dmi"
+	dev "github.com/opencord/opendevice-manager/pkg/models/device"
+
+	"github.com/opencord/voltha-lib-go/v4/pkg/log"
+)
+
+/* validateUri() verifies if the ip and port are valid and already registered then return the truth value of the desired state specified by the following 2 switches,
+   wantRegistered: 'true' if the fact of an ip is registered is the desired state
+   includePort: 'true' further checks if <ip>:<port#> does exist in the devicemap in case an ip is found registered
+*/
+func validateUri(ctx context.Context, uri string) (ok bool, err error) {
+	ok = false
+	if !strings.Contains(uri, ":") {
+		logger.Errorw(ctx, "Invalid-uri", log.Fields{"uri-received": uri, "expected-uri": "ip:port"})
+		err = errors.New("incorrect IP address format (<ip>:<port #>)")
+		return
+	}
+	splits := strings.Split(uri, ":")
+	ip, port := splits[0], splits[1]
+	if net.ParseIP(ip) == nil {
+		// also check to see if it's a valid hostname
+		if _, err2 := net.LookupIP(ip); err2 != nil {
+			logger.Errorw(ctx, "Invalid-ip", log.Fields{"uri-received": uri, "ip": ip})
+			err = errors.New("invalid IP address " + ip)
+			return
+		}
+	}
+	if _, err2 := strconv.Atoi(port); err2 != nil {
+		logger.Errorw(ctx, "Invalid-port", log.Fields{"uri-received": uri, "port": port})
+		err = errors.New("Port number " + port + " needs to be an integer")
+		return
+	}
+	ok = true
+	return
+}
+
+// validateStartManagingDeviceReq validates the 'StartManagingDevice' request is proper or not
+func validateStartManagingDeviceReq(ctx context.Context, req *dmi.ModifiableComponent) (resp *dmi.StartManagingDeviceResponse, ok bool) {
+	resp = new(dmi.StartManagingDeviceResponse)
+	resp.DeviceUuid = new(dmi.Uuid)
+	resp.Status = dmi.Status_ERROR_STATUS
+	if ok1, err := validateUri(ctx, req.Uri.Uri); !ok1 {
+		logger.Errorw(ctx, "validation-failed-for-StartManagingDevice-request", log.Fields{"error": err, "req": req})
+		resp.Reason = dmi.StartManagingDeviceResponse_INVALID_PARAMS
+		resp.ReasonDetail = err.Error()
+		return
+	}
+
+	if rec, _ := dev.DBGetByName(ctx, req.Name); rec != nil {
+		logger.Errorw(ctx, "validation-failed-for-StartManagingDevice-request-record-already-exists", log.Fields{"req": req, "rec": rec})
+		resp.Reason = dmi.StartManagingDeviceResponse_DEVICE_ALREADY_MANAGED
+		resp.ReasonDetail = "device already exists and managed with uuid " + rec.Uuid + " and uri " + rec.Uri
+		return
+	}
+
+	ok = true
+
+	return
+}
+
+// isValidSetLogLevel check is valid set loglevel request
+func isValidSetLogLevel(ctx context.Context, listEntities []*dmi.EntitiesLogLevel) (bool, error) {
+
+	if len(listEntities) == 0 {
+		// atleast one entities is required for set loglevel
+		logger.Errorw(ctx, "found-empty-entities", log.Fields{"entities": listEntities})
+		return false, errors.New("found empty entities")
+	}
+
+	if len(listEntities) > 1 {
+		// if set Entities more than 1, atleast 1 entity in nested struct
+		for _, entities := range listEntities {
+			if len(entities.Entities) == 0 {
+				logger.Errorw(ctx, "entities-has-empty-entries", log.Fields{"entities": entities})
+				return false, errors.New("set-empty-entries-not-allowed")
+			}
+		}
+	}
+
+	logger.Debug(ctx, "valid-set-log-request")
+	return true, nil
+}