To avoid typical errors while defining ontology contributions to model browser follow the following check list:

## Step 1: Ontology Plug-in

Define an ontology plugin (`org.mylib.ontology`).

Define dependencies from Simantics plugins in MANIFEST.MF/Dependencies/Required Plug-ins:

```
org.simantics.layer0
org.simantics.modeling.ontology
org.simantics.viewpoint.ontology
org.simantics.action.ontology
```

Include the following definitions into your ontology file (*.pgraph):

```
L0 = <http://www.simantics.org/Layer0-1.1>
VP = <http://www.simantics.org/Viewpoint-1.2>
ACT = <http://www.simantics.org/Action-1.1>
MOD = <http://www.simantics.org/Modeling-1.2>
```

Define a new library (www.mylib.org) for your ontology under Simantics database root (*http://*):

```
MY_LIB = <http://www.mylib.org> : L0.Library
  @L0.new
```

Define your ontology under the library and specify its ResourceClass:

```
MY_ONTOLOGY = <http://www.mylib.org/MyOntology-1.0> : L0.Ontology
  @L0.new
  L0.HasResourceClass "org.mylib.MyOntologyResource" : L0.String
```

Check the Name property of ontology plugin in MANIFEST.MF/Overview/General Information. It has to match with URI (without version number) of your ontology.

```
Name: http://www.mylib.org/MyOntology
```

Export the package (org.mylib) of ResourceClass in MANIFEST.MF/Runtime/Exported Packages.

Define a new context and include it into MOD.ModelingActionContext

```
MY_AC = MY_ONTOLOGY.MyActionContext : VP.BrowseContext
VP.BrowseContext.IsIncludedIn MOD.ModelingActionContext
```

Define a new ActionContribution for each action in this context

```
MY_AC
  VP.BrowseContext.HasActionContribution _ : VP.ActionContribution
    L0.HasLabel "My action..."        
    VP.ActionContribution.HasAction MY_ONTOLOGY.MyAction : ACT.Action
    VP.ActionContribution.HasNodeType
      L0.Entity
```

## Step 2: Implementation Plug-in

Define a plugin for implementation (org.mylib). Options: Generate an activator=checked, This plug-in will make contributions to the UI=checked.

Define dependencies from Simantics plugins in *MANIFEST.MF/Dependencies/Required Plug-ins*

```
org.simantics.db.layer0
```

Define a new package `src/org.mylib.actions`.

Define a new Java class `MyAction.java` under `org.mylib.actions` package

```java
package org.mylib.actions;
import org.simantics.db.layer0.adapter.ActionFactory;
import org.simantics.db.Resource;

public class MyAction implements ActionFactory {
    @Override
    public Runnable create(Object target) {
        if (!(target instanceof Resource))
            return null;
        final Resource res = (Resource) target;
        return new Runnable() {
            @Override
            public void run() {
                // TODO: put your code here
            }
        };
    }
}
```

Create a new file (`adapters.xml`, [see spec](../Database/ResourceAdaptation.md)) under implementation plugin to map URI (*unversioned*) of your action to Java class implementation. The content of the file is as follows:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<adapters>
    <target interface="org.simantics.db.layer0.adapter.ActionFactory">
        <resource
            uri="http://www.mylib.org/MyOntology-0.0/MyAction"
            class="org.mylib.actions.MyAction" />       
    </target>
</adapters>
```

You can check correctness of URI by Graph Debugger to search a resource:

```
http://www.mylib.org/MyOntology-1.0/MyAction
```

Note! Use *versioned URI* (0.0 -> 1.0) while searching with Graph Debugger.

Include `adapters.xml` into build configuration in *MANIFEST.MF/Build/Binary Build*. Also, include SCL packages and SCL modules if your use them in your implementation.

Export the implementation package (`org.mylib.actions`) of MyAction.java in *MANIFEST.MF/Runtime/Exported Packages*.

## Step 3: Product

Include the ontology and the implementation plug-ins into your product configuration (Debug Configurations/Plug-ins) and validate Plug-ins dependencies before running the product.