Likpi Fast & Light CMDB
CMDB as Code
that maps infrastructure
the way IT teams
actually think.
Infrastructure complexity doesn't decrease. Your CMDB should make it readable, not add more work.
Maps dependencies, traces change propagation, and automates the tedious work. Thousands of CIs, growing complexity, and still that almost indecent speed.
Everything a CMDB should already know how to do. And what we should finally be able to ask of it:
- Impact analysis
- CMDB as Code & GitOps
- Always-up-to-date documentation
- Native AI
Push to Git. Your CMDB just updated itself.
Start & aboveCMDB as Code keeps your Git repository and your Configuration Management Database continuously aligned, so your infrastructure has one trusted source of truth.
Likpi ingests infrastructure definitions straight from Git. Push a YAML change to any Git provider, and the reconciliation engine merges your Configuration Items and their relationships into your CMDB in real time, flagging deleted CIs automatically, computing the blast radius of risky changes, and never asking a human to fill out a ticket.
If it's not in the repo, it's not in the CMDB.
GitOps Pipeline
Schema Gatekeeper validates infrastructure definitions before they enter the CMDB. GitHub, GitLab and Bitbucket webhooks are cryptographically validated (HMAC SHA-256). Valid infrastructure definitions are reconciled through an isolated staging dataset before reaching your production CMDB.
Zombie CIs, flagged on commit
Zombie CIs identify Configuration Items that no longer exist in your Git repository. Delete a resource from your YAML, and Likpi flags it as a zombie the moment the commit lands, then retires it safely at the next reconciliation cycle. No ticket. No forgotten record six months later.
Blast radius, before production
Blast Radius identifies every downstream Configuration Item affected by a proposed change. Likpi computes the diff before applying it. See every downstream CI a change would make an orphan before it reaches your production dataset, not after the outage.
Git wins, or it doesn't, you decide
Attribute-level precedence lets each data source own only the attributes it knows best. Let Git own static attributes like cost center, let live discovery own dynamic attributes like uptime status. Every attribute follows the source you trust most, without compromising the consistency of your CMDB.
AI GitOps Auditor
The built-in assistant reviews proposed infrastructure changes and runs Root Cause Analysis on your commits. Locally.
Likpi doesn't ask you to maintain two truths,
It makes Git one of them.
Operational before your coffee gets cold.
Most CMDB tools arrive empty. Likpi Fast & Light CMDB ships with DMTF data models, a demo dataset, and a working ETL pipeline. You spend the first hour exploring, not rebuilding.
Download
Free Community Edition. No account, no credit card. One ZIP, one command.
Under 2 minutes
One docker-compose up command deploys the full stack: database, backend, UI. Nothing to configure. Nothing to rebuild.
Explore, not from scratch
DMTF data models already loaded. A demo dataset waiting. Your own data can follow via ETL.
Your infrastructure is connected.
Your visibility isn't.
Dependencies are invisible
When a component changes, what it affects isn't in any tool. It lives in someone's head, which is a fragile architecture.
Propagation isn't mapped
A change looks contained. It cascades. The scope becomes visible after the fact, which is the wrong moment to discover it.
Multiple sources. One truth.
When sources conflict, Likpi's reconciliation engine merges, deduplicates and prioritizes automatically. Fresher data always wins.
Likpi doesn't centralize assets,
It maps the system they form.
Your infrastructure is in Europe.
Your jurisdiction might not be.
Most CMDB platforms run on infrastructure you don't control.
The moment your IT data enters their systems, control becomes contractual.
Likpi Fast & Light CMDB runs on your servers. Control stays technical, not legal.
Cloud data exposure
SaaS CMDB vendors store your IT asset data on infrastructure you don't control.
AI data leaves your perimeter
Every AI-assisted query sends asset data to external US cloud LLMs.
Vendor-defined data residency
You choose the plan. They choose the data center. And the jurisdiction.
Continuous telemetry
Usage metadata, behavioral tracking, collected indefinitely by the vendor.
The CMDB that acts,
not just stores.
Likpi Fast & Light CMDB is built by people who manage complex infrastructures themselves. Every capability exists because we needed it first.
Native AI Assistant
Ollama / LLMs integrated. Users chat with CMDB data; admins design system-wide AI prompts.
> What are the number of Tomcat instances in the cloud ?
> What are the number of orphans (excluding Organization) ?
> Provide the detailed evolution of new CIs by class per month.
> If the Server 'SRV-01' is down, what are the impacted Databases ?
Lifecycle Aging
Auto-transition CI statuses. Soft-deletes. Purge unseen CIs.
Trigger Engine
Real-time event bus. Webhooks or email on CI / relation changes.
Audit History
View lifecycle history and relationships for any CI.
Orphan Detection
Identifies CIs with no relationships, so the model stays clean.
Graph Traversals
Change Mgmt, Risk Mitigation, Root Cause Analysis, Disaster Recovery.
Tenant Management
Grant access to organisations, dashboards or AI per tenant.
Ask instead of search.
Get the answer, not a dashboard to build.
The Native AI Assistant runs a dual-model architecture: a cloud-based reasoning engine translates natural language into secure CMDB queries (NL2SQL), while a local Ollama model summarises results and generates visual outputs, keeping sensitive data fully on-premise.
It turns natural language into CMDB queries, dependency analysis, and real-time insights through a dual AI architecture: one engine generates secure queries, the other summarizes results into actionable outputs.
Every interaction is controllable. System prompts and behavior are fully customizable per environment. Nothing leaves your perimeter.
Turn operational reality
into governed reference architecture.
Start from what is actually running instead of rebuilding architecture documentation manually.
From live graph to reusable model
An architect selects an operational graph and saves it as an abstract, reusable reference model built on the CTIM taxonomy.
Adjust before approval
Reference models can be edited before approval, including logical constraints, source/target cardinalities and service ownership.
DRAFT until formally approved
Architectural changes stay in DRAFT until approved with a CAB or request reference and an approving entity. Versions and approvals are tracked in history.
Reference documentation on demand
Generate a PDF with the visual topology, CI inventory, interface relationships, categorisation matrix and attribute details.
Know where a model runs
Live CIs stay linked to their reference model, so you can see how many instances of an architecture are deployed and filter by organization.
Turn what is already running into a reusable, governed and documented architecture
without rebuilding the same knowledge by hand.
Fast by design,
Not by accident.
Every component was chosen for a reason. No black box. No magic. Just predictable behavior under load.
Java Vert.x + Hazelcast
Reactive, event-driven architecture handling massive concurrency without blocking threads. Distributed in-memory cache for sub-millisecond lookups under bulk loads.
PostgreSQL + JSONB Partitioning
NoSQL flexibility inside a relational engine. JSONB attributes enable hot schema changes without migrations. PARTITION BY LIST delivers linear read performance at any scale.
Decoupled React SPA
Designed for operational workflows, not procurement demos.
CMDB as Code solutions comparison
Not all CMDBs are built on
the same architectural choices.
Within the same category of tool, these differences change what a CMDB can actually deliver. Deployment, automation, sovereignty, AI, scalability: the trade-offs are not the same.
| Criteria | Likpi Fast & Light CMDB | ServiceNow | Freshservice | iTop / GLPI |
|---|---|---|---|---|
| On-premise deployment | ✓ Native | △ Self-hosted option available | ✕ SaaS only | ✓ Yes |
| GitOps-native ingestion | ✓ Native | ✕ No | ✕ No | ✕ No |
| Schema validation before reconciliation | ✓ Native | ✕ No | ✕ No | ✕ No |
| GDPR compliance / no cloud dependency | ✓ Guaranteed | △ Self-hosted option available; cloud is the standard deployment | ✕ Cloud-dependent | △ Partial |
| Native multi-tenancy (ABAC) | ✓ SQL-native | △ Paid module | △ Limited | ✕ No |
| Schema changes without downtime | ✓ No migration required | ✕ Migration required | ✕ Migration required | ✕ No |
| AI assistant | ✓ Dual-Layer AI: LLM + local Ollama, without exposing your data | △ Now Assist, cloud LLM | △ Cloud LLM | ✕ None |
| Dependency graph and impact analysis | ✓ Native, multi-level | △ Separate module | ✕ No | ✕ No |
| Transparent pricing | ✓ Public pricing | ✕ Quote only | ✕ Quote only | ✓ Open source |
| Free Community Edition | ✓ Up to 500 CIs | ✕ No | ✕ No | ✓ Open source |
Likpi Fast & Light CMDB is a CMDB as Code solution that brings together, in a single architecture, capabilities usually scattered across several tools or modules: on-premise deployment, native GitOps ingestion, schema changes without downtime, multi-level impact analysis and a Dual-Layer AI designed not to expose your data.
Transparent pricing. No surprises.
Published rates. No sales gatekeeping. No surprises six months later.
The only self-hosted CMDB with a free tier. Your data, your servers, your rules.
Community Edition
- Core CMDB features
- Full reconciliation
- Triggers + webhooks
- Visual change timeline
- API access & webhooks
- Support via the community forum
CMDB Start
- Core CMDB features
- Full reconciliation
- Triggers + webhooks
- Visual change timeline
- API access & webhooks
- CMDB as Code (GitOps sync)
- Email support · 72 h response time
CMDB Scale
- Core CMDB features
- Full reconciliation
- Triggers + webhooks
- Visual change timeline
- API access & webhooks
- CMDB as Code (GitOps sync)
- High availability · 2 instances
- Email support · 48 h response time
Enterprise / ESN
- Core CMDB features
- Full reconciliation
- Triggers + webhooks
- Visual change timeline
- API access & webhooks
- CMDB as Code (GitOps sync)
- High availability
- Dedicated email support · 4 h response time · 24/7
A tenant is an organization CI type.
Built for teams who think in systems,
not just in tickets.
CMDB Automation
IT teams
Your infrastructure changes fast and dependencies keep multiplying. Keeping a reliable view gets hard when documentation still depends on your team. Likpi's CMDB Automation takes over CI tracking, reconciliation and part of the documentation as things change.
Automate the work that slows you down. Keep your expertise for the work that matters.
Multi-tenant CMDB
MSPs and ESNs
Managing more clients shouldn't mean more tools, more manual steps and more time spent on every environment. Likpi's multi-tenant architecture centralizes the administration of your client environments and cuts the time spent on tracking, reconciliation and documentation.
Reduce the overall cost of delivering CMDB services, so you can compete harder without sacrificing profitability.
On-premise CMDB · GDPR
Compliance-driven organizations
Compliance starts with knowing what your IT estate contains, how its parts connect and where your data stays. Likpi maps CIs and their dependencies, keeps their history and produces the documentation you need for controls and audits. On-premise deployment and its AI architecture keep your CMDB data inside your own infrastructure.
Map, document and trace your infrastructure, so the evidence is there when someone asks for it.
CMDB as Code · GitOps
DevOps & Platform teams
Your infrastructure is already defined in Git. Re-entering it by hand in a CMDB adds work without adding information. With CMDB as Code, Likpi integrates into your Terraform or Ansible workflows through generated likpi.yaml files, syncs changes and automatically reconciles the CMDB with the infrastructure you have actually deployed.
Keep Git as the reference for your infrastructure and let the CMDB keep up.
Built by engineers,
For engineers with opinions.
How it started
Likpi Fast & Light CMDB started as an internal tool, long before it became a product. We built it because we needed it ourselves.
What we stand for
We want the people who use Likpi to stay in control of their infrastructure and their data.
That's why sovereignty isn't an option bolted onto the product: it has shaped the architecture from the start.
That freedom comes with responsibility. We refuse to let Likpi be used for surveillance or unauthorized control.
We've already turned down clients over this line. We'll do it again.
What we refuse
We want to build the tool we wished we had found ourselves: accessible, understandable and free of imposed dependencies.
No vendor lock-in, no unnecessary telemetry, no pricing hidden behind a sales call.
And above all, no promise we couldn't explain, show or keep.
Everything the CMDB does
is available through the API.
Likpi Fast & Light CMDB exposes full REST API coverage over every CMDB object. Automate ingestion, trigger reconciliation and query your infrastructure straight from your pipelines. Built for real production pipelines, not tutorials.
Everything you need to get started.
The documentation covers the platform. The community covers the edge cases.
Technical Documentation
Installation, architecture, API reference, reconciliation playbooks, schema design. Everything from zero to production.
doc.likpi.comCommunity Forum
Ask questions, share configurations, discuss edge cases. The Likpi team reads and replies. Community Edition support lives here.
community.likpi.comProduct Presentation
The full Likpi Fast & Light CMDB deck. Architecture, features, comparison. Share with your team or management.
Download PDFTo understand what is happening,
you first need to know what exists.
An alert, an anomaly or an incident only makes sense in context: which component is involved, what does it depend on, what depends on it, and which business service could be affected?
That's why Likpi starts with the CMDB.
Today
Give infrastructure context
Likpi builds a reliable picture of your components, their relationships and how they change over time.
Tomorrow
Give events meaning
Monitoring, event correlation and ML analytics will be able to use that context to understand not only that an event is happening, but where, why and with what consequences.
Likpi. Infrastructure that understands itself.
Your infrastructure. Your data.
No cloud. No sales process. The Community Edition is free and deploys locally.
Common questions,
answered directly.
CMDB as Code & GitOps
What is CMDB as Code?
CMDB as Code lets you define your infrastructure in YAML files versioned in Git. Likpi ingests them through a webhook and automatically reconciles Configuration Items (CIs) and their relationships with the CMDB.
What is the difference between CMDB as Code and Infrastructure as Code?
Infrastructure as Code provisions infrastructure. CMDB as Code documents and reconciles it. Both can start from the same Git sources, keeping deployed infrastructure and the CMDB aligned.
What happens when a resource disappears from the YAML?
Likpi detects the missing CI, flags it as a zombie, then retires it in a controlled way at the next reconciliation cycle. No manual cleanup is needed.
Does Likpi work with Terraform and Ansible?
Yes. Your Terraform or Ansible pipelines can generate a likpi.yaml file, which Likpi then ingests and reconciles through CMDB as Code.
What if Git and live discovery disagree?
You set precedence attribute by attribute. Git can be the reference for static data, while live discovery takes priority for dynamic data.
Dependency Mapping & Impact Analysis
Can Likpi map dependencies and analyze their impact?
Yes. The dependency graph lets you explore relationships between CIs and compute the blast radius of a change, to identify what could be affected.
Can I analyze a change before it reaches production?
Yes. Likpi computes its blast radius before it enters the production dataset, and you can validate your YAML against the live CMDB schema from your CI pipeline.
Can I turn existing infrastructure into an architecture model?
Yes. An operational graph can be saved as a reusable reference model based on the CTIM taxonomy: Category, Type, Item, Model.
Can architecture models be approved and documented?
Yes. Models move from DRAFT to APPROVED after formal validation, with a full history of versions and approvals. Likpi can also generate their PDF documentation: topology, CI inventory, relationships and attributes.
Can I track where an architecture model is deployed?
Yes. CIs stay linked to their reference model, so you can identify its instances and the organization they belong to.
Deployment & Data Sovereignty
Can Likpi run on-premise?
Yes. Likpi is self-hosted on your own infrastructure, on Linux with Docker, with no required dependency on a third-party cloud for your CMDB data.
Is Likpi free?
A free Community Edition manages up to 500 CIs with 2 users. Additional features and capacity are available in the paid editions.
Is Likpi open source?
No. Likpi is proprietary professional software with a free Community Edition.
Does Likpi support multiple tenants?
Yes. Likpi supports multiple isolated organizations (tenants) with separate access management. Licensing and capacity depend on the edition.
AI, API & Automation
Does Likpi include an AI assistant?
Yes. The assistant lets you query the CMDB in natural language to find CIs, spot orphans or analyze impact. Its Dual-Layer AI architecture is designed to avoid exposing sensitive CMDB data to an external LLM.
Does Likpi have an API?
Yes. The REST API covers CMDB objects and lets you automate ingestion, reconciliation and infrastructure queries.
About Likpi
What is Likpi?
Likpi Fast & Light CMDB is a professional, self-hosted CMDB that centralizes, reconciles and connects infrastructure data. It combines CMDB as Code, GitOps, dependency mapping, automation and an AI assistant.
Who is Likpi for?
IT teams, DevOps and Platform teams, MSPs/ESNs and integrators, and organizations with sovereignty or compliance requirements.
Where can I find the technical documentation?
Full documentation, including installation, architecture, CMDB as Code and the API reference, is available at doc.likpi.com.