The general fact is that every mathematical structure of size $\kappa$, in a language of size at most $\kappa$, can be coded as a (connected, undirected, simple) graph of size $\kappa$. What I mean is that this coding process respects isomorphism, so that structure $M$ is isomorphic to $M'$ if and only if the corresponding graph encodings are isomorphic as graphs. It follows that since there are $2^\kappa$ many non-isomorphic structures (e.g. partial orders, groups, subsets of $\langle\kappa,<\rangle$, or what have you), there must also be $2^\kappa$ many non-isomorphic graphs.

In this way, the isomorphism problem of $\mathcal{L}$-structures of size $\kappa$ reduces to the graph isomorphism problem, and this is a sense in which graph-isomorphism is complete. For example, since for countable structures such as countable groups or partial orders, the graph-encoding process is Borel, it follows that the isomorphism relation for countable groups or basically for any kind of countable structures is Borel reducible to the graph isomorphism relation on countable graphs, in the sense of Borel equivalence relation theory.

There are many accounts of the graph encoding, and it is a good exercise to construct your own. But to say a little more about it, suppose we have a structure $\langle\kappa,\ldots\rangle$ with domain $\kappa$. We first aim to reduce to directed graphs. We may think of the relations and functions of the structures in terms of their graphs, and thereby reduce to coding subsets of various $\kappa^n$. And we can encode the copies of these $\kappa^n$ and their projection functions, so that we can tell whether a node in the graph is representing an element of $\kappa$ or a pair or a triple and how they project and so on, and then we can also code any subset of these by adding a node that points directly at the satisfying instances, plus some extra rigid structure that uniquely determines the pointing node. Finally, we reduce from directed graphs to graphs. One way to do this is to replace each directed edge with an assemblage of undirected edges, in such a way that we can tell which are the endpoints and which way the original edge pointed.

When I teach my graduate logic course, we usually do this coding explicitly, and the particular encoding that I use results in connected simple graphs.