How to make a graph from the produced in python

complete update :

• if bi-directional is not important, then the adjM is tri-diagonal
• if not more than 3 edges per node are allowed, then each row and each column of adjM has 3 or less "1"
• the code follows the tri-diagnoal structure required
• step 1: fill in 3 edges starting from each node (follow the rows of adjM)
• step 2: but then some nodes may receive more than 3 edges, so remove some of them until there are 3 left only (follow the columnes of adjM)
• step 3: remove the self-adjacencies
• yes, it might happen that the graph will not be connected due to the random processes. Then repeat the runs till you are happy with.

The structure of adjM looks reasonable now at least. The graph however presents at node 12 more connections than can be seen in the adjM matrix. (so there is still an improvement necessary....)

import numpy as np
import networkx as nx
import matplotlib.pyplot as plt

Nnodes = 16
Nedges = 3

#---- 0. to initialize: generate a random adjacency matrix 
rng = np.random.default_rng()
adjM = rng.integers(1, size=(Nnodes,Nnodes))  # random adjacency matrix / with upper=1 it is a zero matrix


#---- 1. for eaach node generate randomly Nedges edges ("sending" connections alongs the rows of adjM)
for node in range(Nnodes):
    dd = Nnodes-node
    rand_ind = np.random.choice(np.arange(node,Nnodes), size=min(dd,Nedges), replace=False, p=None) # generate randomly indexes
                                                                                       # you might use replace=False too with different results
    adjM[node, rand_ind] = 1   # insert the connections        

#---- 2. for each node eliminate randomly edges that are more than Nedges ("receiving" connections alongs the columns of adjM)
for node in range(Nnodes):          # run through the columns of adjM
    dd = Nnodes-node
    a = adjM[:,node]                # select a column = receiving connections
    jnz = np.array(a.nonzero())     # indices of the non-zero elements
    Nnz = jnz.shape[1]              # number of  non-zero elements
    
    if Nnz > Nedges:                # ...then randomly select Nedges edges only 
        jchoice = np.random.choice(jnz.ravel(),  size=min(Nedges,Nedges), replace=False, p=None)
        #print('            jchoice', jchoice)
        adjM[:,node] = 0
        adjM[jchoice, node] = 1           
        
 #---- 3. remove self-adjacency
jDiag = np.arange(Nnodes)
adjM[jDiag, jDiag] = 0         # set the diagonals to zero
print(adjM) 
        
#---- grafics
plt.spy(adjM, precision=0, marker=None, markersize=12, aspect='equal', origin='upper')
plt.show()
gr = nx.from_numpy_matrix(adjM)
nx.draw_networkx(gr, with_labels=True, node_size=400, node_color='#7d99f5',  edge_color='orange', width=2, font_weight='bold')
plt.show()

Addition to your code (function check_graph () fix two problems we have discussed). Also, according your way of generation of adjacency matrix, you won't face second problem, so you can comment out second section in function.

def check_graph(graph, max_conn):
    # 1) remove self loops
    graph.remove_edges_from(nx.selfloop_edges(graph))

    # 2) remove random edge(s) if limit of edges per node have been exceeded
    for i in graph.nodes():
        # list of connections - nodes that are connected to the selected node 'i'
        nei = list(graph.neighbors(i))
        if len(nei) > max_conn:
            graph.remove_edges_from(
                # like if len(nei) - max_conn = 5 - 4 = 1, then one random edge will be selected
                np.random.choice(nei, size=(len(nei)-max_conn))
            )

# <-- insert your code here -->  N = 20

gr = nx.from_numpy_matrix(my_matrix)
check_graph(gr, max_conn=N)
nx.draw_networkx(gr, with_labels=True, node_color='#7d99f5')

Result looks a bit strange for me, but I don't know purposes of your graph, probably, it's okay.