Overview

Functional Architecture

Likpi Overview

LIKPI is a software solution that allows you to manage, analyze, and visualize your entire IT infrastructure topology and configuration items in real time. It is a highly scalable, event-driven platform built on a reactive architecture (Eclipse Vert.x) and backed by PostgreSQL.

The platform transforms a passive database into an active automation orchestrator, utilising a real-time event bus, dynamic rule evaluation, and automated action dispatching. It provides a single system of record for IT infrastructure, supporting advanced multi-dataset reconciliation, AI-driven analytics (AIOps), high-availability clustering, and granular multi-tenant access control.

Business Value

IT infrastructure management helps organizations empower their vision in order to identify risks, reduce downtime, and maintain service availability.

However, although a reliable CMDB is widely considered a key driver of IT operations and business processes improvement, finding a solution able to manage a huge amount of dynamic infrastructure data, prevent stale discovery data, and easily extract root-cause values in real time remains a challenge. Likpi Fast & Light CMDB has been designed from the beginning to solve this.

With Likpi, you can:

  • Manage several millions of Configuration Items (CIs) with dynamic, schema-less extended attributes.
  • Extract your Key Performance Indicators and perform instant Impact Analysis or Dependency Mapping thanks to our graph traversal capabilities.
  • Detect infrastructure drift in real time, track immutable audit changes, and trigger a remedy automatically.

Architecture & High-Level Topology

The LIKPI CMDB follows a decoupled, modular, Zero-Trust design. The system consists of the following tiers:

  • Tier 1 – Frontend: End users and APIs access the modern React SPA. Access is strictly scoped using a multi-tenant concept and Row-Level Security.
  • Tier 2 – Routing: An API Gateway / Load Balancer distributes inbound traffic.
  • Tier 3 – Compute: Multiple Vert.x application nodes form an active-active cluster, synchronised via a Hazelcast Grid.
  • Tier 4 – Intelligence: A local Ollama model and a Cloud AI engine provide cognitive services.
  • Tier 5 – Storage: A PostgreSQL Primary database with read-only replicas ensures data durability and read scalability.

Backend Core & Platform

The Java/Vert.x backend handles the fundamental operational logic, persistence, and platform security:

  • Reactive HTTP/API Router: A non-blocking API gateway managing all inbound REST requests.
  • PostgreSQL Persistence: Manages database interactions, schema-less JSONB operations, and table partitioning.
  • Activity & Reconciliation Engine: The “brain” of the CMDB, processing merges from staging datasets (SANDBOX) into PRODUCTION by enforcing identification rules, resolving UUIDs, and calculating attribute precedence.
  • Real-time Trigger Engine: Triggers any automation on demand or based on configuration state changes.
  • RBAC & Multi-Tenant Security: Enforces Row-Level Security (RLS) and JWT-based Role-Based Access Control (RBAC) to cryptographically validate and separate data between tenants.
  • License & Quota Service: Validates the platform’s license and enforces limits on HA nodes, CI counts, and users.

Frontend User Interface (UI)

The UI is a responsive Single Page Application (SPA) built with React, TypeScript, and Vite, styled with Tailwind CSS. Key modules include:

  • Graph Explorer: An interactive canvas (React Flow) for visually exploring CI dependencies.
  • Data Explorer: A tabular data management interface with an advanced query builder.
  • Dashboard Factory: A no-code, drag-and-drop editor for building and consuming operational analytical dashboards.
  • AIOps Assistant: A chat interface for natural language to SQL (NL2SQL) queries to query assets easily.

CMDB-as-Code (Native GitOps)

Likpi features a native GitOps engine that empowers infrastructure and development teams to manage Configuration Items (CIs) and relationships using declarative YAML files (likpi.yaml) stored directly in Git (GitHub, GitLab, Bitbucket).

By easily ingesting declarative infrastructure manifests, users can reconcile conflicting data sources with granular precedence rules. Instead of relying on manual ticket entry or fragile ETL scripts, Likpi intercepts Git webhooks in real-time. It stages the incoming data in isolated Virtual Datasets and relies on the smart Reconciliation Engine to safely merge changes into Production. This ensures your code and your CMDB are always perfectly synchronized, complete with automated cleanup of deleted assets to prevent Zombie CIs.

Likpi Planning Stages

The workflow below shows how to reach Likpi business values with real-time topological mapping, AI-driven insights, and automated data reconciliation.

Planning Stages