Skip to main content

Intro / Quick Start

The Information Toolbench (ITB) is a lightweight but powerful metadata modeling platform designed to help teams structure, manage, and distribute metadata consistently across systems.
It enables you to capture models, define templates, and integrate metadata into your wider data landscape with minimal friction.

See the Feature Matrix for everything ITB can do, grouped by area, and which edition (Public / Enterprise) ships each feature.

What ITB offers​

  • Intuitive Modeling – Define metadata structures and relationships through a clear and flexible model.
  • Template Engine – Generate documentation, configuration files, or integration artifacts directly from your metadata.
  • Extensible by Design – ITB encourages extensions rather than modifications, ensuring stability and upgradeability.
  • Automation Friendly – Integrate ITB into your workflows via CLI, APIs, or CI/CD pipelines.
  • Lightweight & Modular – Use only the modules you need, and add more as your use cases grow.

Who ITB is for​

ITB is ideal for teams that:

  • Need consistent metadata across tools and processes
  • Want to generate artifacts from metadata automatically
  • Prefer a modular, open, and transparent modeling approach
  • Don't want the overhead of large enterprise modeling tools
  • Want a proven structure without restricting future growth

Current State​

ITB is in its first version — functional, useful, and already applied in practice — but with a lot of potential still to unfold.
Expect rapid evolution, more modules, deeper integration options, and ongoing stabilization.

To run ITB locally​

Everything you need is in the public distribution repository, github.com/BanianAG/itb. The images are public — no docker login, no account.

One thing has to be fetched first: a licence file. It is free of charge and self-service at itb.banian.ch/license. The API verifies it at startup and refuses to start without it, which from the outside looks like a container that stops with no useful log.

git clone https://github.com/BanianAG/itb.git && cd itb
cp /path/to/your/license.json ./license.json
./itb.sh                                        # Windows without WSL: .\itb.ps1

itb.sh asks four things — version, e-mail, password, port — writes .env, creates ./data, checks the licence and starts the stack. Running it again only starts.

./itb.sh --check         # what is missing? changes nothing, starts nothing
./itb.sh --reconfigure   # answer the questions again
./itb.sh --logs          # start, then follow the API log

Accessing the Web Application​

Open the ITB web interface in your browser:

  • WebApp: http://itb.localhost
  • API: http://api.itb.localhost
  • Documentation: served by the API at http://api.itb.localhost/user-docs/ (open it from the WebApp's Help → Documentation menu)

Note: These URLs work locally thanks to Traefik load balancer. Make sure your /etc/hosts file includes the necessary entries (usually already configured by docker-compose).

Login​

There is no default account. You log in with the e-mail address and password you gave itb.sh. They are stored in .env as ITB_AUTH_USERS in the form user:sha256hex, so the plaintext password is never written down. To change them, run ./itb.sh --reconfigure.

Architecture​

Three parts, each refusing to know what the others handle: the client draws and edits, the API is the system of record and decides what this deployment may do, and the template engine turns the model into artefacts. Your model lives on the API; the browser keeps a working copy so editing stays immediate.

Concept & Architecture explains how they relate, and why the metamodel is the only layer you need to touch to make ITB describe your world.

Model Export & Import (Git-based)​

ITB uses a Git-based workflow for model exchange, providing proper version control with collaboration support.

Pushing a Model​

To share your model or back it up to a Git repository:

  1. Configure a Git connection in the API (repository URL and credentials)
  2. Use the Git Push action to push your current model to the configured repository
  3. The API tracks the Git origin so subsequent pushes target the same remote

Pulling a Model​

To load a model from an existing Git repository:

  1. Ensure a Git connection is configured for the target repository
  2. Use the Git Pull action to pull the latest model from the remote
  3. Optimistic locking prevents accidentally overwriting changes made by other users

Tip: Git-based exchange supports team collaboration — multiple users can push and pull models to the same repository with conflict detection via optimistic locking.

Template Generation​

To generate templates from your current model, follow these steps:

  1. Ensure your model is ready:

    • Make sure your model is properly defined with all entities, relations, and attributes

  2. Generate templates via API:

    • Open the interactive API documentation (Swagger): http://api.itb.localhost/docs
    • Call the generateAll endpoint (no body required)
    • The endpoint cleans stale output before re-generating

  3. Access your templates:

    • Generated templates are available in the output/templates folder
    • Use the export endpoint to download all artifacts as a zip file

Start here​

If you would rather try it than read about it: Walkthrough: from a model to generated artifacts. About 30 minutes — install a demo, generate from it, then change one thing at a time and watch the output change.

Documentation​

The ITB documentation is now integrated directly into the platform:

  • In-App Access: Open Help → Documentation in the WebApp (or go to http://api.itb.localhost/user-docs/)
  • Always Matches Your Version: The docs are baked into the per-edition API image, so they always correspond to your deployed ITB version
  • One build, labelled rather than split: since 2026-08-23 every deployment ships the same pages, and each feature carries a badge saying which licence it needs. Only use-case material stays behind the licence gate

Outlook & Disclaimer​

The current version of ITB is still in beta.
Usage is at your own risk. While the platform is functional, it may contain bugs or incomplete features.

The documentation is continuously being updated to reflect new features, improvements, and best practices.
We recommend checking back regularly for updates and new guidance.