INCEpTION: A Java Annotation Server That Keeps Your Ontology and Your Recommender in the Loop

The Corpus-Building Gap INCEpTION Fills

Most annotation tools assume the schema is fixed before you start. You pick entity types from a dropdown that the tool ships with, and if your project needs a second layer (relations on top of entities, coreference chains, frame slots, document-level labels) you either bolt on a second tool or write your own editor. INCEpTION takes the opposite position: the schema is data you define in the browser, and the README describes stacking entities, relations, coreference, syntax, frames and document labels over the same text, with typed features and slots. The intended user is a research group or an institutional team that has an annotation scheme of its own and an ontology to ground it in. The README names profiles for Wikidata, SNOMED CT, the Gene Ontology, the Human Phenotype Ontology and GND, which tells you the project expects biomedical and library-adjacent work as much as general NLP. If your task is one layer of spans with ten labels, this is more machinery than you need.

Layers, Ontologies and the Recommender Loop

Three mechanisms sit at the centre of the design. The first is the layer model: annotations are not a flat list but a set of typed layers over the same document, and each layer carries its own features and slots. The second is knowledge-base integration. The README states you can load RDF, OWL, OBO, SKOS or Turtle, or query a remote SPARQL endpoint live, and link entities in the text to concepts in that store. That is the difference between tagging a mention as PERSON and asserting it is a specific person in a specific knowledge base. The third is the recommender. According to the README, recommenders train on what you have annotated so far, active learning asks about the cases they are least sure of, and nothing is stored until you accept a suggestion. That last clause matters: the suggestion is a proposal in the editor, not a pre-filled annotation, so the gold standard is not contaminated by model output unless an annotator agrees. The repository topics list active-learning, annotation-suggestions and entity-linking, which is consistent with the README's description of the same three areas.

What Ships in the Repository

The repository is Java, built as a multi-module Maven project; the README image path points at inception/inception-doc/src/main/resources/META-INF/asciidoc, which is where the AsciiDoc documentation sources for the user, admin and developer guides live. The project publishes numbered releases on a short cycle: inception-41.5 on 2026-09-01, 41.4 on 2026-08-18, 41.3 on 2026-08-04. That is roughly a release every two weeks, and it is the single most consequential fact for anyone planning to operate this. A biweekly cadence is good for bug fixes and bad for anyone who treats a deployment as a one-time install. There is a separate repository, inception-project/inception-external-recommender, referenced from the README, for plugging your own models in as recommenders. The README also points to example projects, use cases, and Python scripts and Jupyter notebooks for preparing and post-processing annotations on the project website. I have not run any of this; the description above is what the repository layout, README and release list support.

Deployment: Desktop Installer or Server

The README describes two deployment shapes. A desktop installer for one person, and a server deployment for an institution, on your own hardware, with your own single sign-on. The admin guide is the document to read for the second, and the README links it directly. Beyond the existence of a desktop installer and a server mode, the README does not give installation commands, so I will not invent any. What it does give is the integration surface: a REST API, webhooks, and external recommenders. Those three are how you move documents in and annotations out without asking annotators to click through a UI. The README lists imports of plain text, PDF, HTML and TEI, and exports of UIMA CAS XMI/JSON with custom layers intact, or CoNLL-U. The UIMA CAS detail is worth pausing on: INCEpTION is built on UIMA, and XMI/JSON export preserves the custom layers you defined, which is what makes the round trip back into a UIMA pipeline possible. CoNLL-U export is the escape hatch for anyone whose downstream tooling expects that format, though CoNLL-U cannot represent arbitrary layer structures, so expect loss there.

Where INCEpTION Is the Wrong Tool

The clearest failure mode is scope mismatch. If your annotation task fits in a spreadsheet or a single-label classifier, the layer system, the knowledge base and the recommender are overhead you will pay for in setup time and in server maintenance. The second is operational. A server deployment on your own hardware with your own single sign-on means you own the identity integration, the backups and the upgrades, and the release cadence of roughly two weeks means upgrades are a recurring task rather than an annual one. The README does not state a migration policy; the release notes are where you would look, and I cannot confirm from the supplied material how much manual work a version-to-version upgrade involves. Treat that as an open question to resolve before you commit. The third is the ontology requirement. Entity linking here assumes your target is expressible as RDF, OWL, OBO, SKOS or Turtle, or is reachable over SPARQL. If your authority file is a CSV with no URI scheme, you will be doing conversion work first, and the platform's linking features will not help until that is done.

How It Differs from a Plain Annotation Editor

The obvious alternative is a lightweight span-and-relation editor, of which there are several, or a general-purpose labeling tool that routes text to annotators and collects labels back. The difference in approach is where the intelligence sits. A plain editor is indifferent to what you are annotating: it renders text, you select spans, it stores them. INCEpTION carries a knowledge base and a recommender inside the annotation session. The knowledge base is queried while you annotate, either from a loaded file or from a live SPARQL endpoint, so entity linking is a first-class action rather than a post-processing step. The recommender is trained on the annotations produced in that same project, which means the assistance is specific to your scheme and your domain rather than a general-purpose model. The cost of that difference is weight: a Java server, a database, an ontology to load, and a training loop that only becomes useful once you have annotated enough to train on. If your corpus is small or your scheme is simple, the plain editor wins on time to first annotation. If your scheme has layers and your entities have URIs, the plain editor leaves you to build the linking yourself.

Maintenance, Upgrades and the Apache-2.0 Licence

INCEpTION is Apache License v2.0. That is a permissive licence: it allows commercial and closed-source use, modification and redistribution, subject to the conditions in the licence text, which include preserving copyright and licence notices and stating changes. It also includes a patent grant. I am not a lawyer and this is not legal advice; if you plan to redistribute a modified build or embed it in a product, read LICENSE.txt in the repository and get your own review. On maintenance, the material supports a few concrete statements. Releases arrive about every two weeks. The project is not archived and the last push is recent. The README says INCEpTION is actively developed and maintained, and directs questions to a Google group and issues to GitHub, with a Gitter chat linked in the badge row. The developer guide covers building and extending it, and the external recommender repository is the documented path for custom models. What the material does not give is a support contract, a long-term-support release line, or a stated deprecation policy. If you are deploying for an institution, that absence is the thing to weigh: you are depending on a project maintained by a university group, under a permissive licence that gives you the right to fork if maintenance stops.

Editorial conclusion

Adopt INCEpTION if you need several annotation layers over the same text, entity links into an ontology you control, and a recommender that retrains on your own annotations, and if you can run a Java server or install the desktop build. Do not adopt it if a single flat span-labeling task with a fixed schema is all you need, or if you have no one to own upgrades, because the release cadence is roughly biweekly and the migration path between versions is documented in the release notes rather than enforced by the application. Before committing, verify three things against the version you intend to run: that your import format is listed in the user guide, that your ontology is expressible as RDF, OWL, OBO, SKOS or Turtle or reachable through a SPARQL endpoint, and that your annotators' browsers work with the editor. If those three hold, the platform removes the need to write your own annotation front end.

Official sources

1. inception-project/inception on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases