diff --git a/src/mme-app/mmeGrpcServer/mmeGrpcServer.cpp b/src/mme-app/mmeGrpcServer/mmeGrpcServer.cpp
new file mode 100644
index 0000000..105aee5
--- /dev/null
+++ b/src/mme-app/mmeGrpcServer/mmeGrpcServer.cpp
@@ -0,0 +1,290 @@
+#include <iostream>
+#include <memory>
+#include <string>
+#include <sstream>
+#include <time.h>
+#include <grpcpp/grpcpp.h>
+
+#include "mmeGrpc.grpc.pb.h"
+
+#include <controlBlock.h>
+#include <contextManager/dataBlocks.h>
+#include <contextManager/subsDataGroupManager.h>
+#include <procedureStats.h>
+
+using grpc::Server;
+using grpc::ServerBuilder;
+using grpc::ServerContext;
+using grpc::ServerReader;                                                     
+using grpc::ServerReaderWriter;                                                
+using grpc::ServerWriter; 
+using grpc::Status;
+using mmeGrpc::UeContextReqBuf;
+using mmeGrpc::UeContextRespBuf;
+using mmeGrpc::UeContextRespBuf_SessionContextRespBuf;
+using mmeGrpc::MmeGrpcCli;
+using mmeGrpc::Empty;
+using mmeGrpc::ProcedureStatsRespBuf;
+using mmeGrpc::EventInfoRespBuf;
+using mmeGrpc::EventInfoRespBuf_EventInfoBuf;
+
+using namespace mme;
+
+const string UEStates[4]={ "NoState", "EpsAttached", "Detached", "Idle" };
+// Logic and data behind the server's behavior.
+class MmeGrpcCliServiceImpl final : public MmeGrpcCli::Service {
+  Status GetUeContextInfo(SM::ControlBlock* controlBlk_p, UeContextRespBuf* reply)   {
+	//time_t my_time = time(NULL);
+//	SM::ControlBlock* controlBlk_p = mme::SubsDataGroupManager::Instance()->findControlBlock((uint32_t)request->id());
+	if (controlBlk_p)
+	{
+		UEContext* uecontext_p=dynamic_cast<UEContext*>(controlBlk_p->getPermDataBlock());
+		if (uecontext_p != NULL)
+		{
+ 			//cout << "MY TIME " << ctime(&my_time);
+			
+			// Display IMSI
+			stringstream ss;
+			ss << uecontext_p->getImsi();
+			reply->set_imsi(ss.str());
+
+			// MSISDN
+			ss.str("");
+			ss << uecontext_p->getMsisdn();
+			string ms(ss.str());
+            ms.resize(10);
+            ms.shrink_to_fit();
+            reply->set_msisdn(ms);
+			
+			// TAI
+			ss.str("");
+			const TAI& tai = uecontext_p->getTai().tai_m;
+			ss << "MCC : ";
+			ss << (unsigned char)((tai.plmn_id.idx[0] & 0x0f) + 0x30);
+			ss << (unsigned char)((tai.plmn_id.idx[0] >> 4) + 0x30);
+			ss << (unsigned char)((tai.plmn_id.idx[1] & 0x0f) + 0x30);
+			ss << " MNC : ";
+			ss << (unsigned char)((tai.plmn_id.idx[2] & 0x0f) + 0x30);
+			ss << (unsigned char)((tai.plmn_id.idx[2] >> 4) + 0x30);
+			ss << " TAC : " << tai.tac ;
+			reply->set_tai(ss.str());
+
+			// Cell Identity
+			ss.str("");
+			const CGI& cgi = uecontext_p->getUtranCgi().cgi_m;
+			ss << "0x" << std::hex << cgi.cell_id;
+			reply->set_eutran_cgi(ss.str());
+
+			reply->set_context_id(uecontext_p->getContextID());
+
+			reply->set_enb_ue_s1ap_id(uecontext_p->getS1apEnbUeId());
+			
+			MmContext* mmCtxt = uecontext_p->getMmContext();
+			UE_State_e uestate = mmCtxt->getMmState();
+
+			reply->set_ue_state(UEStates[uestate]);
+
+			SessionContext* sessioncontext_p = uecontext_p->getSessionContext();
+			if (sessioncontext_p != NULL)
+			{
+				UeContextRespBuf_SessionContextRespBuf* session_ctxt = reply->add_sessioncontext();
+				if (session_ctxt)
+				{
+					// APN
+					const apn_name& apn = sessioncontext_p->getAccessPtName().apnname_m;
+					string apnStr((const char*)(apn.val), apn.len);
+					session_ctxt->set_apn(apnStr);
+
+					// PDN address
+					const PAA& PdnAddr = sessioncontext_p->getPdnAddr().paa_m;
+				        char ipStr[INET_ADDRSTRLEN];
+				        inet_ntop(AF_INET, &(PdnAddr.ip_type.ipv4), ipStr, INET_ADDRSTRLEN);
+					session_ctxt->set_pdn_address(ipStr);
+
+					// Bearer ID
+					session_ctxt->set_bearer_id(5);
+
+					// S11 SGW GTP-C TEID
+					const fteid& s11SgwCTeid = sessioncontext_p->getS11SgwCtrlFteid().fteid_m;
+
+					ss.str("");
+					memset(ipStr, 0, INET_ADDRSTRLEN);
+					uint32_t ip = ntohl(s11SgwCTeid.ip.ipv4.s_addr);
+
+					inet_ntop(AF_INET, &(ip), ipStr, INET_ADDRSTRLEN);
+					ss << "IP " << ipStr << " TEID " << s11SgwCTeid.header.teid_gre;
+					session_ctxt->set_s11_sgw_gtpc_teid(ss.str());
+
+					// S5S8 PGW GTP-C TEID
+					const fteid& s5s8PgwCTeid = sessioncontext_p->getS5S8PgwCtrlFteid().fteid_m;
+
+					ss.str("");
+                                        memset(ipStr, 0, INET_ADDRSTRLEN);
+					ip = ntohl(s5s8PgwCTeid.ip.ipv4.s_addr);
+
+					inet_ntop(AF_INET, &(ip), ipStr, INET_ADDRSTRLEN);
+					ss << "IP " << ipStr << " TEID " << s5s8PgwCTeid.header.teid_gre;
+					session_ctxt->set_s5_pgw_gtpc_teid(ss.str());
+					
+					BearerContext* bearerCtxt = sessioncontext_p->getBearerContext();
+					// S1U ENB TEID
+					const fteid& s1uEnbTeid = bearerCtxt->getS1uEnbUserFteid().fteid_m;
+
+					ss.str("");
+                    memset(ipStr, 0, INET_ADDRSTRLEN);
+					ip = ntohl(s1uEnbTeid.ip.ipv4.s_addr);
+
+                    inet_ntop(AF_INET, &(ip), ipStr, INET_ADDRSTRLEN);
+                    ss << "IP " << ipStr << " TEID " << s1uEnbTeid.header.teid_gre;
+					session_ctxt->set_s1u_enb_teid(ss.str());
+
+					// S1U SGW TEID
+				 	const fteid& s1uSgwTeid = bearerCtxt->getS1uSgwUserFteid().fteid_m;
+					ss.str("");
+                                        memset(ipStr, 0, INET_ADDRSTRLEN);
+					ip = ntohl(s1uSgwTeid.ip.ipv4.s_addr);
+
+                                        inet_ntop(AF_INET, &(ip), ipStr, INET_ADDRSTRLEN);
+                                        ss << "IP " << ipStr << " TEID " << s1uSgwTeid.header.teid_gre;
+                                        session_ctxt->set_s1u_sgw_teid(ss.str());
+
+                                        // S5-U PGW TEID
+                                        const fteid& s5uPgwTeid = bearerCtxt->getS5S8PgwUserFteid().fteid_m;
+                                        ss.str("");
+                                        memset(ipStr, 0, INET_ADDRSTRLEN);
+                                        ip = ntohl(s5uPgwTeid.ip.ipv4.s_addr);
+
+                                        inet_ntop(AF_INET, &(ip), ipStr, INET_ADDRSTRLEN);
+                                        ss << "IP " << ipStr << " TEID " << s5uPgwTeid.header.teid_gre;
+                                        session_ctxt->set_s5u_pgw_teid(ss.str());					
+
+				}
+			}	
+		}
+	}
+	return Status::OK;
+
+  }
+
+  Status GetUeContext(ServerContext* context, const UeContextReqBuf* request,
+                  UeContextRespBuf* reply) override 
+  {
+        SM::ControlBlock* controlBlk_p = mme::SubsDataGroupManager::Instance()->findControlBlock((uint32_t)request->id());
+        GetUeContextInfo(controlBlk_p, reply);
+
+        return Status::OK;
+  }
+
+  Status ShowAllMobileContexts(ServerContext* context, const Empty* request,
+                      ServerWriter<UeContextRespBuf>* writer) override 
+  {
+      for (uint32_t i = 1; i <= 8000; i++)
+      {
+              SM::ControlBlock* controlBlk_p = mme::SubsDataGroupManager::Instance()->findControlBlock(i);
+              if (controlBlk_p != NULL && controlBlk_p->getPermDataBlock() != NULL)
+              {
+                      UeContextRespBuf reply;
+                      GetUeContextInfo(controlBlk_p, &reply);
+                      writer->Write(reply);
+              }
+      }
+      return Status::OK;
+  }
+
+  Status GetDebugUeContext(ServerContext* context, const UeContextReqBuf* request,
+		  	EventInfoRespBuf* reply) override {
+	SM::ControlBlock* controlBlk_p = mme::SubsDataGroupManager::Instance()->findControlBlock((uint32_t)request->id());
+	if( controlBlk_p )
+	{
+		UEContext* uecontext_p=dynamic_cast<UEContext*>(controlBlk_p->getPermDataBlock());
+		if( uecontext_p )
+		{
+			MmContext* mmCtxt = uecontext_p->getMmContext();
+			UE_State_e uestate = mmCtxt->getMmState();
+        		reply->set_ue_state(UEStates[static_cast<int>(uestate)]);
+		}
+		deque<SM::debugEventInfo> evtQ = controlBlk_p->getDebugInfoQueue();
+        	for(auto it=evtQ.begin();it!=evtQ.end();it++)
+		{
+        		EventInfoRespBuf_EventInfoBuf* EvtInfo = reply->add_eventinfo();
+	                string strEvent = Events[it->event];
+        	        EvtInfo->set_event(strEvent);
+                	string strState = States[it->state];
+	                EvtInfo->set_state(strState);
+        	        EvtInfo->set_time(ctime(&(it->evt_time)));
+        	}
+	}
+	return Status::OK;
+  }
+
+  Status GetProcStats(ServerContext* context,const Empty* request,
+		  ProcedureStatsRespBuf* reply) override {
+	/*time_t my_time = time(NULL);
+	my_time = time(NULL);
+        cout << "Req recieved at server" << ctime(&my_time);*/
+        reply->set_num_of_air_sent(ProcedureStats::num_of_air_sent);
+		reply->set_num_of_ulr_sent(ProcedureStats::num_of_ulr_sent);
+        reply->set_num_of_processed_aia(ProcedureStats::num_of_processed_aia);
+        reply->set_num_of_processed_ula(ProcedureStats::num_of_processed_ula);
+        reply->set_num_of_auth_req_to_ue_sent(ProcedureStats::num_of_auth_req_to_ue_sent);
+        reply->set_num_of_processed_auth_response(ProcedureStats::num_of_processed_auth_response);
+        reply->set_num_of_sec_mode_cmd_to_ue_sent(ProcedureStats::num_of_sec_mode_cmd_to_ue_sent);
+        reply->set_num_of_processed_sec_mode_resp(ProcedureStats::num_of_processed_sec_mode_resp);
+        reply->set_num_of_esm_info_req_to_ue_sent(ProcedureStats::num_of_esm_info_req_to_ue_sent);
+        reply->set_num_of_handled_esm_info_resp(ProcedureStats::num_of_handled_esm_info_resp);
+        reply->set_num_of_cs_req_to_sgw_sent(ProcedureStats::num_of_cs_req_to_sgw_sent);
+        reply->set_num_of_processed_cs_resp(ProcedureStats::num_of_processed_cs_resp);
+        reply->set_num_of_init_ctxt_req_to_ue_sent(ProcedureStats::num_of_init_ctxt_req_to_ue_sent);
+        reply->set_num_of_processed_init_ctxt_resp(ProcedureStats::num_of_processed_init_ctxt_resp);
+        reply->set_num_of_mb_req_to_sgw_sent(ProcedureStats::num_of_mb_req_to_sgw_sent);
+        reply->set_num_of_processed_attach_cmp_from_ue(ProcedureStats::num_of_processed_attach_cmp_from_ue);
+        reply->set_num_of_processed_mb_resp(ProcedureStats::num_of_processed_mb_resp);
+        reply->set_num_of_attach_done(ProcedureStats::num_of_attach_done);
+        reply->set_num_of_del_session_req_sent(ProcedureStats::num_of_del_session_req_sent);
+        reply->set_num_of_purge_req_sent(ProcedureStats::num_of_purge_req_sent);
+        reply->set_num_of_processed_del_session_resp(ProcedureStats::num_of_processed_del_session_resp);
+        reply->set_num_of_processed_pur_resp(ProcedureStats::num_of_processed_pur_resp);
+        reply->set_num_of_detach_accept_to_ue_sent(ProcedureStats::num_of_detach_accept_to_ue_sent);
+        reply->set_num_of_processed_detach_accept(ProcedureStats::num_of_processed_detach_accept);
+        reply->set_num_of_ue_ctxt_release(ProcedureStats::num_of_ue_ctxt_release);
+        reply->set_num_of_processed_ctxt_rel_resp(ProcedureStats::num_of_processed_ctxt_rel_resp);
+        reply->set_num_of_subscribers_attached(ProcedureStats::num_of_subscribers_attached);
+        reply->set_num_of_rel_access_bearer_req_sent(ProcedureStats::num_of_rel_access_bearer_req_sent);
+        reply->set_num_of_rel_access_bearer_resp_received(ProcedureStats::num_of_rel_access_bearer_resp_received);
+        reply->set_num_of_s1_rel_req_received(ProcedureStats::num_of_s1_rel_req_received);
+        reply->set_num_of_s1_rel_cmd_sent(ProcedureStats::num_of_s1_rel_cmd_sent);
+        reply->set_num_of_s1_rel_comp_received(ProcedureStats::num_of_s1_rel_comp_received);
+        reply->set_num_of_clr_received(ProcedureStats::num_of_clr_received);
+        reply->set_num_of_cla_sent(ProcedureStats::num_of_cla_sent);
+        reply->set_num_of_detach_req_to_ue_sent(ProcedureStats::num_of_detach_req_to_ue_sent);
+        reply->set_num_of_detach_accept_from_ue(ProcedureStats::num_of_detach_accept_from_ue);		
+        reply->set_total_num_of_subscribers(ProcedureStats::total_num_of_subscribers);
+        reply->set_num_of_subscribers_detached(ProcedureStats::num_of_subscribers_detached); 	
+	reply->set_num_of_tau_response_to_ue_sent(ProcedureStats::num_of_tau_response_to_ue_sent);
+		
+	//reply->set_num_of_ddn_received(ProcedureStats::num_of_ddn_received);
+        return Status::OK;
+  }
+
+};
+
+void * RunServer(void* data) {
+  std::string server_address("0.0.0.0:50051");
+  MmeGrpcCliServiceImpl service;
+
+  ServerBuilder builder;
+  // Listen on the given address without any authentication mechanism.
+  builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
+  // Register "service" as the instance through which we'll communicate with
+  // clients. In this case it corresponds to an *synchronous* service.
+  builder.RegisterService(&service);
+  // Finally assemble the server.
+  std::unique_ptr<Server> server(builder.BuildAndStart());
+  std::cout << "Server listening on " << server_address << std::endl;
+
+  // Wait for the server to shutdown. Note that some other thread must be
+  // responsible for shutting down the server for this call to ever return.
+  server->Wait();
+
+  return NULL;
+}