Likpi Fast & Light CMDB
CMDB as code
that maps infrastructure
the way IT teams
actually think.
Infrastructure complexity doesn't decrease. Likpi makes it readable.
Maps dependencies. Traces propagation. Surfaces what changes before it cascades.
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.
SaaS CMDB vendors store your IT asset data on infrastructure you don't control.
Every AI-assisted query sends asset data to external US cloud LLMs.
You choose the plan. They choose the data center. And the jurisdiction.
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 your infrastructure.
It answers.
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.
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.
The architecture gap,
What commercial platforms can't guarantee.
Most CMDB tools trade one compromise for another. Likpi Fast & Light CMDB doesn't.
| Criteria | Likpi CMDB | ServiceNow | Freshservice | iTop / GLPI |
|---|---|---|---|---|
| On-premise deployment | ✓ Native | ✕ US cloud only | ✕ SaaS only | ✓ Yes |
| GitOps-native ingestion | ✓ Native | ✕ No | ✕ No | ✕ No |
| Schema validation before reconciliation | ✓ Native | ✕ No | ✕ No | ✕ No |
| GDPR compliant / No cloud dependency | ✓ Guaranteed | ✕ Cloud-dependent | ✕ Cloud-dependent | △ Partial |
| Native multi-tenancy (ABAC) | ✓ SQL-native | △ Paid module | △ Limited | ✕ No |
| Dynamic schema, zero downtime | ✓ JSONB hot-reload | ✕ Migration required | ✕ Migration required | ✕ No |
| On-premise AI assistant | ✓ Ollama, local | △ Now Assist (cloud LLM) | △ Cloud LLM | ✕ None |
| Graph traversal & impact analysis | ✓ Recursive CTE native | △ Separate module | ✕ No | ✕ No |
| Transparent pricing | ✓ Published | ✕ Opaque, on request | ✕ On request | ✓ Open source |
| Free Community Edition | ✓ Yes, up to 500 CIs | ✕ No | ✕ No | ✓ Open source |
Most CMDBs are either cloud-dependent or self-hosted with high operational overhead. Cloud platforms centralize control externally, while open-source tools require significant maintenance to scale. Likpi is fully on-premise and AI-native, designed for real-time infrastructure intelligence without external dependencies.
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.
- CMDB core engine
- Full reconciliation engine
- Trigger engine + webhooks
- Audit visual timeline
- API access & webhooks
- Community forum only
- CMDB core engine
- Full reconciliation engine
- Trigger engine + webhooks
- Audit visual timeline
- API access & webhooks
- CMDB as code (GitOps sync)
- Support Email SLA 72h
- CMDB core engine
- Full reconciliation engine
- Trigger engine + webhooks
- Audit visual timeline
- API access & webhooks
- CMDB as code (GitOps sync)
- HA cluster with 2 instances
- Support Email SLA 48h
- CMDB core engine
- Full reconciliation engine
- Trigger engine + webhooks
- Audit visual timeline
- API access & webhooks
- CMDB as code (GitOps sync)
- HA cluster
- Support dedicated Email SLA 4h 24/7
A tenant is an organization CI type.
Built for teams who think in systems,
not just in tickets.
IT teams
3 to 10 people, multiple environments, dependencies growing faster than the documentation. The complexity is real. The visibility shouldn't be optional.
MSPs and ESNs
Multiple client environments, each isolated, each with its own constraints. Sometimes inherited in a state that defies explanation. One platform for all of them.
Compliance-driven organizations
GDPR isn't a checkbox. Cloud CMDB vendors can't give you what "your data stays with you" actually means in front of an auditor. Likpi can.
DevOps & Platform teams
Your infrastructure already lives in Git. A CMDB that makes you type it twice isn't tooling, it's a tax. Generate your likpi.yaml straight from Terraform or Ansible pipelines. Git becomes the operational source of truth for your infrastructure, while Likpi continuously reconciles your CMDB.
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
Data sovereignty isn't marketing for us. It's a design constraint. Likpi will never be used as a tool for surveillance or unauthorized monitoring. We've declined clients because of this. We'll do it again.
What we refuse
No vendor lock-in. No unnecessary telemetry. No cloud dependency. No opaque pricing. And no product that promises everything without explaining anything.
API-first. Integrate everything.
Likpi Fast & Light CMDB exposes full REST API coverage over every CMDB object. Automate ingestion, trigger reconciliation, query your infrastructure. Designed for real 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 PDFThe foundation of a unified platform.
A sovereign foundation for managing, understanding, and evolving your IT infrastructure. Built to unify operational truth and intelligence in a single system.
Sovereign, high-performance CMDB.
A single source of truth for IT assets: configuration management, reconciliation, and AI assistance, all operating inside your perimeter.
Full-stack AIOps.
Monitoring, ML analytics, event correlation, and business alignment, built on the same sovereign foundation.
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.
What is CMDB as Code?
CMDB as Code stores your infrastructure definitions as version-controlled YAML files in Git instead of maintaining them manually. Likpi ingests these definitions via webhook and reconciles your Configuration Items and their relationships automatically through its reconciliation engine.
What is the difference between CMDB as Code and Infrastructure as Code?
Infrastructure as Code defines and provisions infrastructure. CMDB as Code documents and reconciles Configuration Items and their relationships from the same Git repository. Together, they keep infrastructure definitions and operational reality aligned.
What happens when I delete a resource from my YAML file?
Likpi detects the missing CI on the next commit, flags it as a zombie, and retires it safely at the next reconciliation cycle. No manual cleanup, no forgotten records.
Can I see what a change will break before it reaches production?
Yes. Likpi computes the blast radius of every commit and flags each downstream CI the change would orphan before it reaches your production dataset. You can also validate your YAML against the live CMDB schema directly in your CI pipeline.
What if Git and live discovery disagree on a CI's state?
You define attribute-level precedence rules. Let Git own static attributes like cost center, and let live discovery own dynamic attributes like uptime status.