diff --git a/internal/common/omci/get.go b/internal/common/omci/get.go
index 384fc0b..73e53ac 100644
--- a/internal/common/omci/get.go
+++ b/internal/common/omci/get.go
@@ -119,7 +119,7 @@
 		EntityID: entityID,
 		Attributes: me.AttributeValueMap{
 			"ManagedEntityId": entityID,
-			"EquipmentId":     toOctets("12345123451234512345", 20),
+			"EquipmentId":     ToOctets("12345123451234512345", 20),
 			"OpticalNetworkUnitManagementAndControlChannelOmccVersion": 180,
 			"VendorProductCode":                           0,
 			"SecurityCapability":                          1,
@@ -157,8 +157,8 @@
 		EntityID: entityID,
 		Attributes: me.AttributeValueMap{
 			"ManagedEntityId":         entityID,
-			"VendorId":                toOctets("BBSM", 4),
-			"Version":                 toOctets("v0.0.1", 14),
+			"VendorId":                ToOctets("BBSM", 4),
+			"Version":                 ToOctets("v0.0.1", 14),
 			"SerialNumber":            append(onuSn.VendorId, onuSn.VendorSpecific...),
 			"TrafficManagementOption": 0,
 			"Deprecated":              0,
@@ -166,8 +166,8 @@
 			"AdministrativeState":     0,
 			"OperationalState":        0,
 			"OnuSurvivalTime":         10,
-			"LogicalOnuId":            toOctets("BBSM", 24),
-			"LogicalPassword":         toOctets("BBSM", 12),
+			"LogicalOnuId":            ToOctets("BBSM", 24),
+			"LogicalPassword":         ToOctets("BBSM", 12),
 			"CredentialsStatus":       0,
 			"ExtendedTcLayerOptions":  0,
 		},
@@ -224,12 +224,12 @@
 		},
 		Attributes: me.AttributeValueMap{
 			"ManagedEntityId": 0,
-			"Version":         toOctets("00000000000001", 14),
+			"Version":         ToOctets("00000000000001", 14),
 			"IsCommitted":     committed,
 			"IsActive":        active,
 			"IsValid":         1,
-			"ProductCode":     toOctets("product-code", 25),
-			"ImageHash":       toOctets("broadband-sim", 16),
+			"ProductCode":     ToOctets("product-code", 25),
+			"ImageHash":       ToOctets("broadband-sim", 16),
 		},
 		Result:        me.Success,
 		AttributeMask: attributeMask,
@@ -253,7 +253,7 @@
 		},
 		Attributes: me.AttributeValueMap{
 			"ManagedEntityId": 0,
-			"MacAddress":      toOctets("aabbcc", 6),
+			"MacAddress":      ToOctets("aabbcc", 6),
 		},
 		Result:        me.Success,
 		AttributeMask: attributeMask,
@@ -590,7 +590,7 @@
 	}
 }
 
-func toOctets(str string, size int) []byte {
+func ToOctets(str string, size int) []byte {
 	asciiBytes := []byte(str)
 
 	if len(asciiBytes) < size {
diff --git a/internal/common/omci/mib_test.go b/internal/common/omci/mib_test.go
index a4ffbb7..139e3e1 100644
--- a/internal/common/omci/mib_test.go
+++ b/internal/common/omci/mib_test.go
@@ -71,27 +71,99 @@
 
 func TestCreateMibUploadNextResponse(t *testing.T) {
 
+	const uniPortCount = 4
+
+	var (
+		onuDataEntityId = EntityID{0x00, 0x00}
+		onu2gEntityId   = EntityID{0x00, 0x00}
+		anigEntityId    = EntityID{tcontSlotId, aniGId}
+	)
+
+	// create a fake mibDb, we only need to test that given a CommandSequenceNumber
+	// we return the corresponding entry
+	// the only exception is for OnuData in which we need to replace the MibDataSync attribute with the current value
+	mibDb := MibDb{
+		NumberOfCommands: 4,
+		items:            []MibDbEntry{},
+	}
+
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.OnuDataClassID,
+		onuDataEntityId,
+		me.AttributeValueMap{"MibDataSync": 0},
+	})
+
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.CircuitPackClassID,
+		circuitPackEntityID,
+		me.AttributeValueMap{
+			"Type":          ethernetUnitType,
+			"NumberOfPorts": uniPortCount,
+			"SerialNumber":  ToOctets("BBSM-Circuit-Pack", 20),
+			"Version":       ToOctets("v0.0.1", 20),
+		},
+	})
+
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.AniGClassID,
+		anigEntityId,
+		me.AttributeValueMap{
+			"Arc":                         0,
+			"ArcInterval":                 0,
+			"Deprecated":                  0,
+			"GemBlockLength":              48,
+			"LowerOpticalThreshold":       255,
+			"LowerTransmitPowerThreshold": 129,
+			"OnuResponseTime":             0,
+			"OpticalSignalLevel":          57428,
+			"PiggybackDbaReporting":       0,
+			"SignalDegradeThreshold":      9,
+			"SignalFailThreshold":         5,
+			"SrIndication":                1,
+			"TotalTcontNumber":            8,
+			"TransmitOpticalLevel":        3171,
+			"UpperOpticalThreshold":       255,
+			"UpperTransmitPowerThreshold": 129,
+		},
+	})
+
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.Onu2GClassID,
+		onu2gEntityId,
+		me.AttributeValueMap{
+			"ConnectivityCapability":                      127,
+			"CurrentConnectivityMode":                     0,
+			"Deprecated":                                  1,
+			"PriorityQueueScaleFactor":                    1,
+			"QualityOfServiceQosConfigurationFlexibility": 63,
+			"Sysuptime":                                   0,
+			"TotalGemPortIdNumber":                        8,
+			"TotalPriorityQueueNumber":                    64,
+			"TotalTrafficSchedulerNumber":                 8,
+		},
+	})
+
 	tests := []struct {
 		name string
 		args mibArgs
 		want mibExpected
 	}{
 		{"mibUploadNext-0", createTestMibUploadNextArgs(t, 1, 0),
-
-			mibExpected{messageType: omci.MibUploadNextResponseType, transactionId: 1, entityID: 0, entityClass: me.OnuDataClassID, attributes: map[string]interface{}{"MibDataSync": MDS}}},
+			mibExpected{messageType: omci.MibUploadNextResponseType, transactionId: 1, entityID: onuDataEntityId.ToUint16(), entityClass: me.OnuDataClassID, attributes: map[string]interface{}{"MibDataSync": MDS}}},
 		{"mibUploadNext-1", createTestMibUploadNextArgs(t, 2, 1),
-			mibExpected{messageType: omci.MibUploadNextResponseType, transactionId: 2, entityID: 257, entityClass: me.CircuitPackClassID, attributes: map[string]interface{}{"Type": uint8(47), "NumberOfPorts": uint8(4)}}},
-		{"mibUploadNext-4", createTestMibUploadNextArgs(t, 3, 4),
-			mibExpected{messageType: omci.MibUploadNextResponseType, transactionId: 3, entityID: 257, entityClass: me.CircuitPackClassID, attributes: map[string]interface{}{"PowerShedOverride": uint32(0)}}},
-		{"mibUploadNext-10", createTestMibUploadNextArgs(t, 4, 10),
-			mibExpected{messageType: omci.MibUploadNextResponseType, transactionId: 4, entityID: 258, entityClass: me.PhysicalPathTerminationPointEthernetUniClassID, attributes: map[string]interface{}{"SensedType": uint8(47)}}},
+			mibExpected{messageType: omci.MibUploadNextResponseType, transactionId: 2, entityID: circuitPackEntityID.ToUint16(), entityClass: me.CircuitPackClassID, attributes: map[string]interface{}{"Type": uint8(47), "NumberOfPorts": uint8(4)}}},
+		{"mibUploadNext-2", createTestMibUploadNextArgs(t, 3, 2),
+			mibExpected{messageType: omci.MibUploadNextResponseType, transactionId: 3, entityID: anigEntityId.ToUint16(), entityClass: me.AniGClassID, attributes: map[string]interface{}{"GemBlockLength": uint16(48)}}},
+		{"mibUploadNext-3", createTestMibUploadNextArgs(t, 4, 3),
+			mibExpected{messageType: omci.MibUploadNextResponseType, transactionId: 4, entityID: onuDataEntityId.ToUint16(), entityClass: me.Onu2GClassID, attributes: map[string]interface{}{"TotalPriorityQueueNumber": uint16(64)}}},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 
 			// create the packet starting from the mibUploadNextRequest
-			data, _ := CreateMibUploadNextResponse(tt.args.omciPkt, tt.args.omciMsg, MDS)
+			data, err := CreateMibUploadNextResponse(tt.args.omciPkt, tt.args.omciMsg, MDS, &mibDb)
+			assert.NilError(t, err)
 			omciMsg, omciPkt := omciBytesToMsg(t, data)
 
 			assert.Equal(t, omciMsg.MessageType, tt.want.messageType)
@@ -107,65 +179,15 @@
 			assert.Equal(t, msgObj.ReportedME.GetEntityID(), tt.want.entityID)
 
 			for k, v := range tt.want.attributes {
-				attr, _ := msgObj.ReportedME.GetAttribute(k)
+				attr, err := msgObj.ReportedME.GetAttribute(k)
+				assert.NilError(t, err)
 				assert.Equal(t, attr, v)
 			}
 		})
 	}
-}
 
-type pqueueExpected struct {
-	entityId    uint16
-	relatedPort uint32
-}
-
-func TestGeneratePriorityQueueMe(t *testing.T) {
-
-	tests := []struct {
-		name     string
-		sequence uint16
-		want     pqueueExpected
-	}{
-		{"generate-pq-downstream-1", 26,
-			pqueueExpected{entityId: 1, relatedPort: 16842752}},
-		{"generate-pq-downstream-2", 30,
-			pqueueExpected{entityId: 2, relatedPort: 16842753}},
-		{"generate-pq-downstream-3", 58,
-			pqueueExpected{entityId: 9, relatedPort: 16842760}},
-		{"generate-pq-upstream-1", 28,
-			pqueueExpected{entityId: 32769, relatedPort: 2147549184}},
-		{"generate-pq-upstream-2", 32,
-			pqueueExpected{entityId: 32770, relatedPort: 2147549185}},
-		{"generate-pq-upstream-3", 60,
-			pqueueExpected{entityId: 32777, relatedPort: 2147614720}},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			reportedMe, meErr := GeneratePriorityQueueMe(tt.sequence)
-			if meErr.GetError() != nil {
-				t.Fatal(meErr.Error())
-			}
-
-			assert.Equal(t, reportedMe.GetEntityID(), tt.want.entityId)
-
-			relatedPort, _ := reportedMe.GetAttribute("RelatedPort")
-			assert.Equal(t, relatedPort, tt.want.relatedPort)
-		})
-	}
-
-	// test that the related ports are unique
-	allRelatedPorts := make(map[uint32]struct{})
-	for v := 26; v <= 281; v++ {
-		reportedMe, meErr := GeneratePriorityQueueMe(uint16(v))
-		if meErr.GetError() != nil {
-			t.Fatal(meErr.Error())
-		}
-		relatedPort, _ := reportedMe.GetAttribute("RelatedPort")
-		allRelatedPorts[relatedPort.(uint32)] = struct{}{}
-	}
-
-	// we report 128 queues total, but each of them is comprised of 2 messages
-	// that's why the 256 iterations
-	assert.Equal(t, len(allRelatedPorts), 128)
+	// now try to get a non existing command from the DB anche expect an error
+	args := createTestMibUploadNextArgs(t, 1, 20)
+	_, err := CreateMibUploadNextResponse(args.omciPkt, args.omciMsg, MDS, &mibDb)
+	assert.Error(t, err, "mibdb-does-not-contain-item")
 }
diff --git a/internal/common/omci/mibpackets.go b/internal/common/omci/mibpackets.go
index 6d22200..8db0709 100755
--- a/internal/common/omci/mibpackets.go
+++ b/internal/common/omci/mibpackets.go
@@ -23,25 +23,12 @@
 	"github.com/opencord/omci-lib-go"
 	me "github.com/opencord/omci-lib-go/generated"
 	log "github.com/sirupsen/logrus"
-	"strconv"
 )
 
 var omciLogger = log.WithFields(log.Fields{
 	"module": "OMCI",
 })
 
-// we have a fixed number of 8 T-CONTS
-var reportedTcontsMeId = []uint16{
-	32769,
-	32770,
-	32771,
-	32772,
-	32773,
-	32774,
-	32775,
-	32776,
-}
-
 // NOTE this is basically the same as https://github.com/opencord/voltha-openonu-adapter-go/blob/master/internal/pkg/onuadaptercore/omci_cc.go#L545-L564
 // we should probably move it in "omci-lib-go"
 func Serialize(msgType omci.MessageType, request gopacket.SerializableLayer, tid uint16) ([]byte, error) {
@@ -112,10 +99,7 @@
 	return HexEncode(pkt)
 }
 
-func CreateMibUploadResponse(tid uint16) ([]byte, error) {
-
-	numberOfCommands := uint16(291) //NOTE should this be configurable? (not until we have moved all the messages away from omci-sim)
-
+func CreateMibUploadResponse(tid uint16, numberOfCommands uint16) ([]byte, error) {
 	request := &omci.MibUploadResponse{
 		MeBasePacket: omci.MeBasePacket{
 			EntityClass: me.OnuDataClassID,
@@ -168,7 +152,7 @@
 	return msgObj, nil
 }
 
-func CreateMibUploadNextResponse(omciPkt gopacket.Packet, omciMsg *omci.OMCI, mds uint8) ([]byte, error) {
+func CreateMibUploadNextResponse(omciPkt gopacket.Packet, omciMsg *omci.OMCI, mds uint8, mibDb *MibDb) ([]byte, error) {
 
 	msgObj, err := ParseMibUploadNextRequest(omciPkt)
 	if err != nil {
@@ -183,256 +167,28 @@
 		"CommandSequenceNumber": msgObj.CommandSequenceNumber,
 	}).Trace("received-omci-mibUploadNext-request")
 
-	var reportedMe *me.ManagedEntity
-	var meErr me.OmciErrors
+	if msgObj.CommandSequenceNumber > mibDb.NumberOfCommands {
+		omciLogger.WithFields(log.Fields{
+			"CommandSequenceNumber": msgObj.CommandSequenceNumber,
+			"MibDbNumberOfCommands": mibDb.NumberOfCommands,
+		}).Error("mibdb-does-not-contain-item")
+		return nil, fmt.Errorf("mibdb-does-not-contain-item")
+	}
+	currentEntry := mibDb.items[int(msgObj.CommandSequenceNumber)]
+	reportedMe, meErr := me.LoadManagedEntityDefinition(currentEntry.classId, me.ParamData{
+		EntityID:   currentEntry.entityId.ToUint16(),
+		Attributes: currentEntry.params,
+	})
 
-	switch msgObj.CommandSequenceNumber {
-	case 0:
-		reportedMe, meErr = me.NewOnuData(me.ParamData{Attributes: me.AttributeValueMap{
-			"MibDataSync": mds,
-		}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewOnuData %v", meErr.Error())
-		}
+	if meErr.GetError() != nil {
+		omciLogger.Errorf("Error while generating %s: %v", currentEntry.classId.String(), meErr.Error())
+	}
 
-	case 1:
-		reportedMe, meErr = me.NewCircuitPack(me.ParamData{
-			EntityID: 257, // first UNI
-			Attributes: me.AttributeValueMap{
-				"Type":          47,
-				"NumberOfPorts": 4,
-				"SerialNumber":  toOctets("BBSM-Circuit-Pack", 20),
-				"Version":       toOctets("v0.0.1", 20),
-			}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewCircuitPack %v", meErr.Error())
+	if reportedMe.GetClassID() == me.OnuDataClassID {
+		// if this is ONU-Data we need to replace the MDS
+		if err := reportedMe.SetAttribute("MibDataSync", mds); err.GetError() != nil {
+			omciLogger.Errorf("Error while setting mds in %s: %v", currentEntry.classId.String(), meErr.Error())
 		}
-	case 2:
-		reportedMe, meErr = me.NewCircuitPack(me.ParamData{
-			EntityID: 257, // first UNI
-			Attributes: me.AttributeValueMap{
-				"VendorId":            "ONF",
-				"AdministrativeState": 0,
-				"OperationalState":    0,
-				"BridgedOrIpInd":      0,
-			}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewCircuitPack %v", meErr.Error())
-		}
-	case 3:
-		reportedMe, meErr = me.NewCircuitPack(me.ParamData{
-			EntityID: 257, // first UNI
-			Attributes: me.AttributeValueMap{
-				"EquipmentId":                 toOctets("BBSM-Circuit-Pack", 20),
-				"CardConfiguration":           0,
-				"TotalTContBufferNumber":      8,
-				"TotalPriorityQueueNumber":    8,
-				"TotalTrafficSchedulerNumber": 16,
-			}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewCircuitPack %v", meErr.Error())
-		}
-	case 4:
-		reportedMe, meErr = me.NewCircuitPack(me.ParamData{
-			EntityID: 257, // first UNI
-			Attributes: me.AttributeValueMap{
-				"PowerShedOverride": uint32(0),
-			}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewCircuitPack %v", meErr.Error())
-		}
-	case 5:
-		reportedMe, meErr = me.NewCircuitPack(me.ParamData{
-			EntityID: 257,
-			Attributes: me.AttributeValueMap{
-				"Type":          238,
-				"NumberOfPorts": 4, //number of UNI for this device
-				"SerialNumber":  toOctets("BBSM-Circuit-Pack-2", 20),
-				"Version":       toOctets("v0.0.1", 20),
-			}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewCircuitPack %v", meErr.Error())
-		}
-	case 6:
-		reportedMe, meErr = me.NewCircuitPack(me.ParamData{
-			EntityID: 257, // first UNI
-			Attributes: me.AttributeValueMap{
-				"VendorId":            "ONF",
-				"AdministrativeState": 0,
-				"OperationalState":    0,
-				"BridgedOrIpInd":      0,
-			}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewCircuitPack %v", meErr.Error())
-		}
-	case 7:
-		reportedMe, meErr = me.NewCircuitPack(me.ParamData{
-			EntityID: 257, // first UNI
-			Attributes: me.AttributeValueMap{
-				"EquipmentId":                 toOctets("BBSM-Circuit-Pack", 20),
-				"CardConfiguration":           0,
-				"TotalTContBufferNumber":      0,
-				"TotalPriorityQueueNumber":    8,
-				"TotalTrafficSchedulerNumber": 0,
-			}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewCircuitPack %v", meErr.Error())
-		}
-	case 8:
-		reportedMe, meErr = me.NewCircuitPack(me.ParamData{
-			EntityID: 257, // first UNI
-			Attributes: me.AttributeValueMap{
-				"PowerShedOverride": uint32(0),
-			}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewCircuitPack %v", meErr.Error())
-		}
-	case 9, 10, 11, 12:
-		// NOTE we're reporting for different UNIs, the IDs are 257, 258, 259, 260
-		meInstance := 248 + msgObj.CommandSequenceNumber
-		reportedMe, meErr = me.NewPhysicalPathTerminationPointEthernetUni(me.ParamData{
-			EntityID: meInstance,
-			Attributes: me.AttributeValueMap{
-				"ExpectedType":                  0,
-				"SensedType":                    47,
-				"AutoDetectionConfiguration":    0,
-				"EthernetLoopbackConfiguration": 0,
-				"AdministrativeState":           0,
-				"OperationalState":              0,
-				"ConfigurationInd":              3,
-				"MaxFrameSize":                  1518,
-				"DteOrDceInd":                   0,
-				"PauseTime":                     0,
-				"BridgedOrIpInd":                2,
-				"Arc":                           0,
-				"ArcInterval":                   0,
-				"PppoeFilter":                   0,
-				"PowerControl":                  0,
-			}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewPhysicalPathTerminationPointEthernetUni %v", meErr.Error())
-		}
-	case 13, 14, 15, 16, 17, 18, 19, 20:
-		reportedMe, meErr = me.NewTCont(me.ParamData{
-			// NOTE fetch the correct T-CONT MeID based on the sequence number
-			EntityID: reportedTcontsMeId[msgObj.CommandSequenceNumber-13],
-			Attributes: me.AttributeValueMap{
-				"AllocId": 65535,
-			},
-		})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewTCont %v", meErr.Error())
-		}
-	case 21:
-		reportedMe, meErr = me.NewAniG(me.ParamData{
-			EntityID: 32769, // same as the first T-CONT
-			Attributes: me.AttributeValueMap{
-				"Arc":                         0,
-				"ArcInterval":                 0,
-				"Deprecated":                  0,
-				"GemBlockLength":              48,
-				"LowerOpticalThreshold":       255,
-				"LowerTransmitPowerThreshold": 129,
-				"OnuResponseTime":             0,
-				"OpticalSignalLevel":          57428,
-				"PiggybackDbaReporting":       0,
-				"SignalDegradeThreshold":      9,
-				"SignalFailThreshold":         5,
-				"SrIndication":                1,
-				"TotalTcontNumber":            8,
-				"TransmitOpticalLevel":        3171,
-				"UpperOpticalThreshold":       255,
-				"UpperTransmitPowerThreshold": 129,
-			},
-		})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewAniG %v", meErr.Error())
-		}
-	case 22, 23, 24, 25:
-		// NOTE we're reporting for different UNIs, the IDs are 257, 258, 259, 260
-		meInstance := 235 + msgObj.CommandSequenceNumber
-		reportedMe, meErr = me.NewUniG(me.ParamData{
-			EntityID: meInstance,
-			Attributes: me.AttributeValueMap{
-				"AdministrativeState":         0,
-				"Deprecated":                  0,
-				"ManagementCapability":        0,
-				"NonOmciManagementIdentifier": 0,
-				"RelayAgentOptions":           0,
-			}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewUniG %v", meErr.Error())
-		}
-	// Prior-Q with mask downstream
-	case 26, 30, 34, 38, 42, 46, 50, 54,
-		58, 62, 66, 70, 74, 78, 82, 86,
-		90, 94, 98, 102, 106, 110, 114, 118,
-		122, 126, 130, 134, 138, 142, 146, 150,
-		154, 158, 162, 166, 170, 174, 178, 182,
-		186, 190, 194, 198, 202, 206, 210, 214,
-		218, 222, 226, 230, 234, 238, 242, 246,
-		250, 254, 258, 262, 266, 270, 274, 278,
-		// Prior-Q with attribute list downstream
-		27, 31, 35, 39, 43, 47, 51, 55,
-		59, 63, 67, 71, 75, 79, 83, 87,
-		91, 95, 99, 103, 107, 111, 115, 119,
-		123, 127, 131, 135, 139, 143, 147, 151,
-		155, 159, 163, 167, 171, 175, 179, 183,
-		187, 191, 195, 199, 203, 207, 211, 215,
-		219, 223, 227, 231, 235, 239, 243, 247,
-		251, 255, 259, 263, 267, 271, 275, 279,
-		// Prior-Q with mask upstream
-		28, 32, 36, 40, 44, 48, 52, 56,
-		60, 64, 68, 72, 76, 80, 84, 88,
-		92, 96, 100, 104, 108, 112, 116, 120,
-		124, 128, 132, 136, 140, 144, 148, 152,
-		156, 160, 164, 168, 172, 176, 180, 184,
-		188, 192, 196, 200, 204, 208, 212, 216,
-		220, 224, 228, 232, 236, 240, 244, 248,
-		252, 256, 260, 264, 268, 272, 276, 280,
-		// Prior-Q with attribute list upstream
-		29, 33, 37, 41, 45, 49, 53, 57,
-		61, 65, 69, 73, 77, 81, 85, 89,
-		93, 97, 101, 105, 109, 113, 117, 121,
-		125, 129, 133, 137, 141, 145, 149, 153,
-		157, 161, 165, 169, 173, 177, 181, 185,
-		189, 193, 197, 201, 205, 209, 213, 217,
-		221, 225, 229, 233, 237, 241, 245, 249,
-		253, 257, 261, 265, 269, 273, 277, 281:
-
-		reportedMe, meErr = GeneratePriorityQueueMe(msgObj.CommandSequenceNumber)
-
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewPriorityQueue %v", meErr.Error())
-		}
-	case 282, 283, 284, 285, 286, 287, 288, 289:
-		reportedMe, meErr = me.NewTrafficScheduler(me.ParamData{Attributes: me.AttributeValueMap{
-			"TContPointer":            32768, // NOTE does this need to change?
-			"TrafficSchedulerPointer": 0,
-			"Policy":                  02,
-			"PriorityWeight":          0,
-		}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewTrafficScheduler %v", meErr.Error())
-		}
-	case 290:
-		reportedMe, meErr = me.NewOnu2G(me.ParamData{Attributes: me.AttributeValueMap{
-			"ConnectivityCapability":                      127,
-			"CurrentConnectivityMode":                     0,
-			"Deprecated":                                  1,
-			"PriorityQueueScaleFactor":                    1,
-			"QualityOfServiceQosConfigurationFlexibility": 63,
-			"Sysuptime":                                   0,
-			"TotalGemPortIdNumber":                        8,
-			"TotalPriorityQueueNumber":                    64,
-			"TotalTrafficSchedulerNumber":                 8,
-		}})
-		if meErr.GetError() != nil {
-			omciLogger.Errorf("NewOnu2G %v", meErr.Error())
-		}
-	default:
-		omciLogger.Warn("unsupported-CommandSequenceNumber-in-mib-upload-next", msgObj.CommandSequenceNumber)
-		return nil, nil
 	}
 
 	response := &omci.MibUploadNextResponse{
@@ -457,83 +213,3 @@
 
 	return pkt, nil
 }
-
-func GeneratePriorityQueueMe(sequence uint16) (*me.ManagedEntity, me.OmciErrors) {
-
-	iteration := sequence - 26
-
-	// we report 256 messages for priority queues,
-	// 128 downstream and 128 upstream
-	// we repeat 64 times the quartet:
-	// - downstream with mask
-	// - downstream with attributes (same MeID as the previous)
-	// - upstream with mask
-	// - upstream with attributes (same MeID as the previous)
-
-	// very ugly way to define whether the priority queue is upstream or downstream
-	// (first 2 blocks are downstream, second two are upstream)
-	// for example sequence 26, 27 are downstream
-	// sequence 28, 29 are upstream
-	isDownstream := ((sequence-26)%4 == 0) || ((sequence-27)%4 == 0)
-	// entityIds are:
-	// - 1 to 64 for downstream (hex 0001 to 0040)
-	// - 32769 to 32832 for upstream (hex 8001 to 8040)
-	var entityId uint16
-	if isDownstream {
-		entityId = (iteration)/4 + 1
-	} else {
-		entityId = (iteration)/4 + 32769
-	}
-
-	var relatedPort uint32
-	if isDownstream {
-		// downstream the related port is:
-		// - Circuit Pack/ UNI port of UNI Port (01 01/04)
-		// - priority 0 to 15 -> iteration%16
-
-		// every 16 iteration (of 4 commands) we move to the next the TCONT MeID
-		uniPort := int(iteration/64) + 1
-		priority := (iteration / 4) % 16
-
-		// concat the uniPort and priority in an hex string
-		// we have a single circuit pack, so we hardcode it
-		v := fmt.Sprintf("010%x000%x", uniPort, priority)
-
-		// convert back to int
-		k, _ := strconv.ParseInt(v, 16, 64)
-		relatedPort = uint32(k)
-	} else {
-		// upstream the related port is:
-		// - Tcont MeID -> reportedTcontsMeId[ceil(iteration/4/8)]
-		// - priority 0 to 7 -> iteration%8
-
-		// every 8 iteration (of 4 commands) we move to the next the TCONT MeID
-		tcontMe := reportedTcontsMeId[int(iteration/32)]
-		priority := (iteration / 4) % 8
-
-		// concat the tcontMe and priority in an hex string
-		v := fmt.Sprintf("%x000%x", tcontMe, priority)
-
-		// convert back to int
-		k, _ := strconv.ParseInt(v, 16, 64)
-		relatedPort = uint32(k)
-	}
-
-	return me.NewPriorityQueue(me.ParamData{
-		EntityID: entityId,
-		Attributes: me.AttributeValueMap{
-			"QueueConfigurationOption":                            0,
-			"MaximumQueueSize":                                    100,
-			"AllocatedQueueSize":                                  100,
-			"DiscardBlockCounterResetInterval":                    0,
-			"ThresholdValueForDiscardedBlocksDueToBufferOverflow": 0,
-			"RelatedPort":                                         relatedPort,
-			"TrafficSchedulerPointer":                             264,
-			"Weight":                                              1,
-			"BackPressureOperation":                               1,
-			"BackPressureTime":                                    0,
-			"BackPressureOccurQueueThreshold":                     0,
-			"BackPressureClearQueueThreshold":                     0,
-		},
-	})
-}
diff --git a/internal/common/omci/onu_mib_db.go b/internal/common/omci/onu_mib_db.go
new file mode 100644
index 0000000..c8696a7
--- /dev/null
+++ b/internal/common/omci/onu_mib_db.go
@@ -0,0 +1,362 @@
+/*
+ * Copyright 2018-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 omci
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	me "github.com/opencord/omci-lib-go/generated"
+)
+
+type MibDbEntry struct {
+	classId  me.ClassID
+	entityId EntityID
+	params   me.AttributeValueMap
+}
+
+type MibDb struct {
+	NumberOfCommands uint16
+	items            []MibDbEntry
+}
+
+type EntityID []byte
+
+func (e EntityID) ToString() string {
+	return hex.EncodeToString(e)
+}
+
+func (e EntityID) ToUint16() uint16 {
+	return binary.BigEndian.Uint16(e)
+}
+
+func (e EntityID) ToUint32() uint32 {
+	return binary.BigEndian.Uint32(e)
+}
+
+const (
+	cardHolderOnuType byte = 0x01 // ONU is a single piece of integrated equipment
+	ethernetUnitType  byte = 0x2f // Ethernet BASE-T
+	xgsPonUnitType    byte = 0xee // XG-PON10G10
+	cardHolderSlotID  byte = 0x01
+	tcontSlotId       byte = 0x80 // why is this not the same as the cardHolderSlotID, it does not point to anything
+	aniGId            byte = 0x01
+
+	upstreamPriorityQueues   = 8  // Number of queues for each T-CONT
+	downstreamPriorityQueues = 16 // Number of queues for each PPTP
+	tconts                   = 8  // NOTE will we ever need to configure this?
+	// trafficSchedulers        = 8  // NOTE will we ever need to configure this?
+)
+
+var (
+	cardHolderEntityID  = EntityID{cardHolderOnuType, cardHolderSlotID}
+	circuitPackEntityID = cardHolderEntityID // is the same as that of the cardholder ME containing this circuit pack instance
+)
+
+func GenerateUniPortEntityId(id uint32) EntityID {
+	return EntityID{cardHolderSlotID, byte(id)}
+}
+
+// creates a MIB database for a ONU
+// CircuitPack and CardHolder are static, everything else can be configured
+func GenerateMibDatabase(uniPortCount int) (*MibDb, error) {
+
+	mibDb := MibDb{
+		items: []MibDbEntry{},
+	}
+
+	// the first element to return is the ONU-Data
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.OnuDataClassID,
+		EntityID{0x00, 0x00},
+		me.AttributeValueMap{"MibDataSync": 0}, // FIXME this needs to be parametrized before sending the response
+	})
+
+	// then we report the CardHolder
+	// NOTE we have not report it till now, so leave it commented out
+	//mibDb.items = append(mibDb.items, MibDbEntry{
+	//	me.CardholderClassID,
+	//	cardHolderEntityID,
+	//	me.AttributeValueMap{
+	//		"ActualPlugInUnitType":   cardHolderOnuType,
+	//		"ExpectedPlugInUnitType": ethernetUnitType,
+	//	},
+	//})
+
+	// circuitPack XG-PON10G10
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.CircuitPackClassID,
+		circuitPackEntityID,
+		me.AttributeValueMap{
+			"Type":          xgsPonUnitType,
+			"NumberOfPorts": 1, // NOTE is this the ANI port? must be
+			"SerialNumber":  ToOctets("BBSM-Circuit-Pack-ani", 20),
+			"Version":       ToOctets("v0.0.1", 20),
+		},
+	})
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.CircuitPackClassID,
+		circuitPackEntityID,
+		me.AttributeValueMap{
+			"VendorId":            "ONF",
+			"AdministrativeState": 0,
+			"OperationalState":    0,
+			"BridgedOrIpInd":      0,
+		},
+	})
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.CircuitPackClassID,
+		circuitPackEntityID,
+		me.AttributeValueMap{
+			"EquipmentId":                 ToOctets("BBSM-Circuit-Pack", 20),
+			"CardConfiguration":           0,
+			"TotalTContBufferNumber":      8,
+			"TotalPriorityQueueNumber":    8,
+			"TotalTrafficSchedulerNumber": 0,
+		},
+	})
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.CircuitPackClassID,
+		circuitPackEntityID,
+		me.AttributeValueMap{
+			"PowerShedOverride": uint32(0),
+		},
+	})
+
+	// ANI-G
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.AniGClassID,
+		EntityID{tcontSlotId, aniGId},
+		me.AttributeValueMap{
+			"Arc":                         0,
+			"ArcInterval":                 0,
+			"Deprecated":                  0,
+			"GemBlockLength":              48,
+			"LowerOpticalThreshold":       255,
+			"LowerTransmitPowerThreshold": 129,
+			"OnuResponseTime":             0,
+			"OpticalSignalLevel":          57428,
+			"PiggybackDbaReporting":       0,
+			"SignalDegradeThreshold":      9,
+			"SignalFailThreshold":         5,
+			"SrIndication":                1,
+			"TotalTcontNumber":            8,
+			"TransmitOpticalLevel":        3171,
+			"UpperOpticalThreshold":       255,
+			"UpperTransmitPowerThreshold": 129,
+		},
+	})
+
+	// circuitPack Ethernet
+	// NOTE the circuit pack is divided in multiple messages as too big to fit in a single one
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.CircuitPackClassID,
+		circuitPackEntityID,
+		me.AttributeValueMap{
+			"Type":          ethernetUnitType,
+			"NumberOfPorts": uniPortCount,
+			"SerialNumber":  ToOctets("BBSM-Circuit-Pack", 20),
+			"Version":       ToOctets("v0.0.1", 20),
+		},
+	})
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.CircuitPackClassID,
+		circuitPackEntityID,
+		me.AttributeValueMap{
+			"VendorId":            "ONF",
+			"AdministrativeState": 0,
+			"OperationalState":    0,
+			"BridgedOrIpInd":      0,
+		},
+	})
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.CircuitPackClassID,
+		circuitPackEntityID,
+		me.AttributeValueMap{
+			"EquipmentId":                 ToOctets("BBSM-Circuit-Pack", 20),
+			"CardConfiguration":           0,
+			"TotalTContBufferNumber":      8,
+			"TotalPriorityQueueNumber":    8,
+			"TotalTrafficSchedulerNumber": 16,
+		},
+	})
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.CircuitPackClassID,
+		circuitPackEntityID,
+		me.AttributeValueMap{
+			"PowerShedOverride": uint32(0),
+		},
+	})
+
+	// PPTP and UNI-Gs
+	// NOTE this are dependent on the number of UNI this ONU supports
+	// Through an identical ID, the UNI-G ME is implicitly linked to an instance of a PPTP
+	for i := 1; i <= uniPortCount; i++ {
+		uniEntityId := GenerateUniPortEntityId(uint32(i))
+
+		mibDb.items = append(mibDb.items, MibDbEntry{
+			me.PhysicalPathTerminationPointEthernetUniClassID,
+			uniEntityId,
+			me.AttributeValueMap{
+				"ExpectedType":                  0,
+				"SensedType":                    ethernetUnitType,
+				"AutoDetectionConfiguration":    0,
+				"EthernetLoopbackConfiguration": 0,
+				"AdministrativeState":           0,
+				"OperationalState":              0,
+				"ConfigurationInd":              3,
+				"MaxFrameSize":                  1518,
+				"DteOrDceInd":                   0,
+				"PauseTime":                     0,
+				"BridgedOrIpInd":                2,
+				"Arc":                           0,
+				"ArcInterval":                   0,
+				"PppoeFilter":                   0,
+				"PowerControl":                  0,
+			},
+		})
+
+		mibDb.items = append(mibDb.items, MibDbEntry{
+			me.UniGClassID,
+			uniEntityId,
+			me.AttributeValueMap{
+				"AdministrativeState":         0,
+				"Deprecated":                  0,
+				"ManagementCapability":        0,
+				"NonOmciManagementIdentifier": 0,
+				"RelayAgentOptions":           0,
+			},
+		})
+
+		// Downstream Queues (related to PPTP)
+		// 16 priorities queues for each UNI Ports
+		// EntityID = cardHolderSlotID + Uni EntityID (0101)
+		for j := 1; j <= downstreamPriorityQueues; j++ {
+			queueEntityId := EntityID{cardHolderSlotID, byte(j)}
+
+			// we first report the PriorityQueue without any attribute
+			mibDb.items = append(mibDb.items, MibDbEntry{
+				me.PriorityQueueClassID,
+				queueEntityId, //was not reported in the original implementation
+				me.AttributeValueMap{},
+			})
+
+			// then we report it with the required attributes
+			// In the downstream direction, the first byte is the slot number and the second byte is the port number of the queue's destination port.
+			relatedPort := append(uniEntityId, 0x00, byte(j))
+			mibDb.items = append(mibDb.items, MibDbEntry{
+				me.PriorityQueueClassID,
+				queueEntityId, //was not reported in the original implementation
+				me.AttributeValueMap{
+					"QueueConfigurationOption":                            0,
+					"MaximumQueueSize":                                    100,
+					"AllocatedQueueSize":                                  100,
+					"DiscardBlockCounterResetInterval":                    0,
+					"ThresholdValueForDiscardedBlocksDueToBufferOverflow": 0,
+					"RelatedPort":                                         relatedPort.ToUint32(),
+					"TrafficSchedulerPointer":                             0, //it was hardcoded to 0x0108 in the current implementation
+					"Weight":                                              1,
+					"BackPressureOperation":                               1,
+					"BackPressureTime":                                    0,
+					"BackPressureOccurQueueThreshold":                     0,
+					"BackPressureClearQueueThreshold":                     0,
+				},
+			})
+		}
+	}
+
+	// T-CONTS and Traffic Schedulers
+	for i := 1; i <= tconts; i++ {
+		tcontEntityId := EntityID{tcontSlotId, byte(i)}
+
+		mibDb.items = append(mibDb.items, MibDbEntry{
+			me.TContClassID,
+			tcontEntityId,
+			me.AttributeValueMap{
+				"AllocId": 65535,
+			},
+		})
+
+		tsEntityId := EntityID{cardHolderSlotID, byte(i)}
+		mibDb.items = append(mibDb.items, MibDbEntry{
+			me.TrafficSchedulerClassID,
+			tsEntityId, //was not reported in the original implementation
+			me.AttributeValueMap{
+				"TContPointer":            tcontEntityId.ToUint16(), // was hardcoded to a non-existing t-cont
+				"TrafficSchedulerPointer": 0,
+				"Policy":                  02,
+				"PriorityWeight":          0,
+			},
+		})
+
+		for j := 1; j <= upstreamPriorityQueues; j++ {
+			queueEntityId := EntityID{tcontSlotId, byte(j)}
+			// Upstream Queues (related to traffic schedulers)
+			// 8 priorities queues per TCONT
+			// EntityID = tcontSlotId + Uni EntityID (8001)
+
+			// we first report the PriorityQueue without any attribute
+			mibDb.items = append(mibDb.items, MibDbEntry{
+				me.PriorityQueueClassID,
+				queueEntityId, //was not reported in the original implementation
+				me.AttributeValueMap{},
+			})
+
+			// then we report it with the required attributes
+			// In the upstream direction, the first 2 bytes are the ME ID of the associated T- CONT, the first byte of which is a slot number, the second byte a T-CONT number.
+			relatedPort := append(tcontEntityId, 0x00, byte(j))
+			mibDb.items = append(mibDb.items, MibDbEntry{
+				me.PriorityQueueClassID,
+				queueEntityId, //was not reported in the original implementation
+				me.AttributeValueMap{
+					"QueueConfigurationOption":                            0,
+					"MaximumQueueSize":                                    100,
+					"AllocatedQueueSize":                                  100,
+					"DiscardBlockCounterResetInterval":                    0,
+					"ThresholdValueForDiscardedBlocksDueToBufferOverflow": 0,
+					"RelatedPort":                                         relatedPort.ToUint32(),
+					"TrafficSchedulerPointer":                             tsEntityId.ToUint16(), //it was hardcoded to 0x0108 in the current implementation
+					"Weight":                                              1,
+					"BackPressureOperation":                               1,
+					"BackPressureTime":                                    0,
+					"BackPressureOccurQueueThreshold":                     0,
+					"BackPressureClearQueueThreshold":                     0,
+				},
+			})
+		}
+	}
+
+	// ONU-2g
+	mibDb.items = append(mibDb.items, MibDbEntry{
+		me.Onu2GClassID,
+		EntityID{0x00, 0x00},
+		me.AttributeValueMap{
+			"ConnectivityCapability":                      127,
+			"CurrentConnectivityMode":                     0,
+			"Deprecated":                                  1,
+			"PriorityQueueScaleFactor":                    1,
+			"QualityOfServiceQosConfigurationFlexibility": 63,
+			"Sysuptime":                                   0,
+			"TotalGemPortIdNumber":                        8,
+			"TotalPriorityQueueNumber":                    64,
+			"TotalTrafficSchedulerNumber":                 8,
+		},
+	})
+
+	mibDb.NumberOfCommands = uint16(len(mibDb.items))
+
+	return &mibDb, nil
+}
diff --git a/internal/common/omci/onu_mib_db_test.go b/internal/common/omci/onu_mib_db_test.go
new file mode 100644
index 0000000..cea0daf
--- /dev/null
+++ b/internal/common/omci/onu_mib_db_test.go
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2018-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 omci
+
+import (
+	"github.com/opencord/omci-lib-go"
+	me "github.com/opencord/omci-lib-go/generated"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestEntityID_ToUint16(t *testing.T) {
+	var id EntityID
+	var res uint16
+
+	id = EntityID{0x01, 0x01}
+	res = id.ToUint16()
+	assert.Equal(t, uint16(257), res)
+
+	id = EntityID{0x00, 0x00}
+	res = id.ToUint16()
+	assert.Equal(t, uint16(0), res)
+}
+
+func Test_GenerateMibDatabase(t *testing.T) {
+	const uniPortCount = 4
+	mibDb, err := GenerateMibDatabase(uniPortCount)
+
+	expectedItems := 9                     //ONU-G + 2 Circuit Packs (4 messages each)
+	expectedItems += 2 * uniPortCount      // 1 PPTP and 1 UniG per UNI
+	expectedItems += 1                     // ANI-G
+	expectedItems += 2 * tconts            // T-CONT and traffic schedulers
+	expectedItems += 1                     // ONU-2g
+	expectedItems += 2 * 8 * tconts        // 8 upstream queues for each T-CONT, and we report each queue twice
+	expectedItems += 2 * 16 * uniPortCount // 16 downstream queues for each T-CONT, and we report each queue twice
+
+	assert.NoError(t, err)
+	assert.NotNil(t, mibDb)
+	assert.Equal(t, expectedItems, int(mibDb.NumberOfCommands))
+
+	// now try to serialize all messages to check on the attributes
+	for _, entry := range mibDb.items {
+		reportedMe, meErr := me.LoadManagedEntityDefinition(entry.classId, me.ParamData{
+			EntityID:   entry.entityId.ToUint16(),
+			Attributes: entry.params,
+		})
+		assert.NoError(t, meErr.GetError())
+
+		response := &omci.MibUploadNextResponse{
+			MeBasePacket: omci.MeBasePacket{
+				EntityClass: me.OnuDataClassID,
+			},
+			ReportedME: *reportedMe,
+		}
+
+		_, err := Serialize(omci.MibUploadNextResponseType, response, uint16(10))
+		assert.NoError(t, err)
+	}
+
+}