Structure language is used in MPS to describe language structure. In XML, it is similar to XMLSchema and DTD. In Database world, it is similar to Database schema declared in SQL DDL. And in systems like yacc, antlr, it is similar to EBNF grammar.
MPS stores all its data in models. A model can have an arbitary number of root nodes. In structure models, root nodes usually are concept declarations, in editor models they mostly are concept editor declarations, and, say, in models with java classes they are java classes. In some sense models are similar to packages in java. A model can import some other models, to allow nodes in this model reference nodes from other models. Also, a model can be written in more than one language, so it can contain nodes, the concepts of which (i.e., their "types") are declared in different languages. For example if you have model with java classes you will import model that represents java.lang package (Now this model is called java.lang@java_stub) and will use language jetbrains.mps.baseLanguage, which contains java-related types like classes, methods and expressions. In MPS code, a model is represented by class jetbrains.mps.smodel.SModel.
A node represents instances of some language concept. Each node has type which is represented by some ConceptDeclaration.
A node may have some properties. The most common property among all of them is name: every class, method, variable has a name.
Also nodes can have links to other nodes. There are two kinds of links in MPS: aggregation links and reference ones. Aggregation is used when you want to say that one (referer) node contains another one (referent), for example if you have class it can contain methods, fields, constructors. References are used if you don't want to or can't use aggregation. For example if you want one class to extend another, you have to have in your extending class a reference link to the parent class. Each link has a role, which is a string which names a relationship between its referer and referent. For example if a class contains a method, it's represented in MPS as an aggregation link from this class to the method with a role "method"; If a class extends some another class, it's represented as a reference link from this class to the parent class with a role "extends".
If you've worked with XML before you can see similarity between nodes and elements and between our properties and xml properties.
When you work with some instance of language concept you suppose some information about it. For example you know that java class has name, any number of methods and can extend some other class. Structure language is used to express such things. For each type of node you create instance of ConceptDeclaration and declare possible properties and links in it. MPS will generate classes with convenience methods from this description.
You may find that some concept declarations extend another ones. That means that the extending concept, in addition to its own properties and links, posesses all properties and links declared in the ancestor concepts.
Property declarations specify what properties could an instance of the given concept possibly have. Each property declaration consists of property name and its type. For example, a property which represents a name of a variable has a name "name" and a type string. There are three simple predefined property types: string, integer and boolean. You may also create your own property types, such as enumeration types and constrained types. For example, a property "bgColor" of EditorCellModel concept has a type _Colors_Enum, which is an enumeration type inhabited by several colors (green, blue, orange, etc.).
Link declarations specify which nodes can be aggregated or referenced by instances of the given concept. In other words, each link declaration declares a kind of relation between instances of a given concept and instances of link declaration's target concept. In a link declaration, one should specify a link kind(i.e. reference or aggregation), a role (the name of a link declaration), target concept (i.e. the concept of nodes to be referenced or aggregated). Also you should specify link cardinality, which can be either 1, 0..1, 1..n and 0..n. Cardinality says about how many nodes should this kind of node refer or aggregate via this kind of link (in other words, how many nodes it should have in this role).
In MPS, you should not set 1..n and 0..n cardinalities to a reference link declaration, it's a mistake. Well, and what to do if you want, for instance, to describe a concept of a java class, for it should refer somehow to a list of the interfaces implemented? You may do the following. First, create a concept, call it, say, InterfaceReference, which contains nothing but a single link to an interface. Then declare in a concept for java class an aggregation link which refers a list of InterfaceReferences.
Some link declarations specialize another link declarations. You may specialize only link declarations from an ancestor concept. A specialized link may have a different role name and a different target concept. But cardinality and link kind will be the same as of the base link, and a target concept should be a descendant of the base link's target concept.
Sometimes you need to specify concept a property or a link which specifies some information that is common for all concept instance. For example you can mark a concept as abstract if you don't want it to be instanciated or you can set short description that will be visible in editor. Concept Links and Properties are similar to java static fields methods.