Repository navigation
Home
AI-ready Customer 360 infrastructure for identity resolution, unified customer profiles, behavioral data, analytics, and activation.
LEO Customer 360 is an open-source Customer 360 and identity-resolution platform designed as a foundation for a composable Customer Data Platform (CDP).
It brings fragmented customer data into a unified, tenant-aware customer model and provides the infrastructure required to build analytics, segmentation, personalization, scoring, AI, and marketing activation on top of that foundation.
Collect → Resolve → Unify → Understand → Activate
Repository: https://github.com/LEO-CDP/leo-customer360
Documentation: https://leo-cdp.github.io/leo-customer360/
Customer data is usually fragmented across websites, mobile applications, POS systems, CRM platforms, advertising platforms, and transactional systems.
The difficult problem is not simply storing this data.
The difficult problem is answering:
Who is this customer, what do we know about them, and what should the business do next?
LEO Customer 360 addresses the foundation of that problem through:
- Identity Resolution — connect records belonging to the same real-world customer
- Golden Customer Records — maintain a unified customer profile
- Identity Graph — preserve relationships between identities, profiles, and business entities
- Behavioral Data — ingest and aggregate customer events
- Segmentation — create reusable customer audiences
- Analytics — expose customer and operational metrics
- AI-ready Data — support embeddings, semantic search, and downstream ML/AI systems
- Activation Infrastructure — provide the foundation for personalization, campaigns, recommendations, and advertising
LEO Customer 360 follows a modular architecture built around PostgreSQL and independently deployable application services.
SOURCE SYSTEMS
│
┌────────────────┼────────────────┐
│ │ │
Web Mobile POS
│ │ │
CRM Advertising Transactions
│ │ │
└────────────────┼────────────────┘
│
▼
┌─────────────────┐
│ Data Ingestion │
│ & Tracking API │
└────────┬────────┘
│
▼
┌──────────────────────┐
│ Raw / Staging Data │
│ PostgreSQL + S3 │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ Identity Resolution │
│ CIR │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ Customer 360 │
│ Golden Records │
└──────────┬───────────┘
│
┌───────────┼───────────┐
▼ ▼ ▼
Segmentation Analytics Identity Graph
│ │ │
└───────────┼───────────┘
▼
┌──────────────────────┐
│ AI / Scoring / │
│ Personalization │
└──────────┬───────────┘
│
▼
BUSINESS ACTIVATION
The current implementation uses PostgreSQL 16 as the primary data plane, with FastAPI application services, Dagster orchestration, Redis caching, Keycloak authentication, and S3/MinIO for tracking-log storage.
| Capability | Description | Status |
|---|---|---|
| Customer 360 | Unified golden customer profiles | ✅ Implemented |
| Identity Resolution | Metadata-driven profile matching and consolidation | ✅ Implemented |
| Identity Graph | Relationships between identities and customer entities | ✅ Implemented |
| Event Tracking | Customer event ingestion and tracking logs | ✅ Implemented |
| Segmentation | Compute and synchronize customer segments | ✅ Implemented |
| Analytics | Tracking-log aggregation and operational reporting | ✅ Implemented |
| REST API | Customer, identity, CRM, reporting and metadata APIs | ✅ Implemented |
| Multi-tenancy | Tenant-aware API access and authorization | ✅ Implemented |
| Authentication | Keycloak-backed authentication and bearer tokens | ✅ Implemented |
| Admin UI | Browser-based Customer 360 administration | ✅ Implemented |
| Ad Serving | Tenant-scoped placements, campaigns and creatives | ✅ Implemented |
| Vector Search | pgvector infrastructure for semantic similarity | 🧩 Infrastructure |
| Customer Scoring | CLV, churn, lead and engagement scoring | 🧩 Infrastructure |
| Personalization | Personalized experiences and recommendations | 🚧 Roadmap |
| Campaign Activation | Automated marketing activation workflows | 🚧 Roadmap |
| AI Agents | AI-assisted customer intelligence and workflows | 🚧 Roadmap |
Identity resolution is the core of LEO Customer 360.
The platform can resolve multiple records into a unified customer identity using configurable metadata-driven matching rules.
For example:
┌───────────────┐
│ Anonymous Web │
│ Visitor │
└───────┬───────┘
│
device_id
│
▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ Mobile App │────▶│ Identity │◀────│ POS │
│ Profile │ │ Resolution │ │ Transaction │
└───────────────┘ │ Engine (CIR) │ └───────────────┘
└───────┬───────┘
│
email / phone /
customer_id /
device_id / ...
│
▼
┌─────────────────┐
│ Master Profile │
│ Customer 360 │
└─────────────────┘
Matching rules are metadata-driven, allowing identity attributes and matching strategies to evolve without hard-coding every identifier into the resolver.
The platform also maintains lineage between master profiles and the raw records that contributed to them, including match method and match score.
The platform is built around a unified customer model containing:
- Master customer profiles
- Raw profiles
- Identity attributes
- Identity links
- Behavioral events
- CRM entities
- Personas
- Segments
- Customer relationships
- Customer scores
- Embeddings
- Operational metadata
The underlying PostgreSQL model supports both conventional relational queries and graph-like customer relationships.
With pgvector, customer profiles and related entities can also store embeddings for semantic search and similarity-based use cases.
LEO Customer 360 includes a dedicated tracking API for behavioral data.
The tracking layer is designed to separate:
Event Collection
↓
Durable Queue
↓
Immutable Tracking Logs
↓
Analytics / Processing
↓
Customer Intelligence
The event pipeline is designed so event collection can evolve independently from downstream Customer 360 processing.
Typical event sources include:
- Web
- Mobile
- POS
- E-commerce
- CRM
- Transactions
- Advertising platforms
- Social platforms
- External APIs
Customer 360 is not only an identity database.
The platform provides infrastructure for understanding customer behavior through:
- Customer segmentation
- Behavioral aggregation
- Customer journey analysis
- CRM relationships
- Identity graph analysis
- Acquisition attribution
- Engagement metrics
- Operational reporting
Implemented backend workflows include identity resolution, segmentation, and analytics, while additional scoring and activation workflows continue to evolve as independent services.
LEO Customer 360 is designed as an AI-ready data foundation, rather than attempting to make the Customer 360 database itself an AI product.
The platform provides structured customer context that can be consumed by downstream AI and machine-learning systems.
Examples include:
"Find customers similar to our highest-value
B2B customers with strong product engagement."
Customer Segment
↓
Embedding
↓
Vector Similarity
↓
Similar Customers
Potential scoring models include:
- Lead Conversion Probability
- Churn Probability
- Customer Lifetime Value
- Engagement Score
- Propensity Scores
- Next Best Action
The platform provides the data model and infrastructure required to store and consume these outputs, while model training and inference can remain independent services.
| Layer | Technology |
|---|---|
| Primary database | PostgreSQL 16 |
| Vector search | pgvector |
| Geospatial data | PostGIS |
| API | FastAPI |
| ORM / data access | SQLAlchemy |
| Workflow orchestration | Dagster |
| Cache / streaming queue | Redis |
| Authentication | Keycloak |
| Object storage | S3 / MinIO |
| Frontend | FastAPI-served web UI |
| Containerization | Docker / Docker Compose |
| Deployment | Docker / Kubernetes |
| Language | Python |
The architecture deliberately uses open-source and composable infrastructure so individual components can be replaced or scaled independently.
leo-customer360/
│
├── customer360-api/ # Customer 360 REST API
├── data-tracking-api/ # Event ingestion and tracking
├── backend-system/ # Dagster orchestration and data jobs
│ ├── identity_resolution/ # Customer Identity Resolution
│ ├── segmentation/ # Customer segmentation
│ ├── analytics/ # Behavioral analytics
│ ├── scoring/ # Scoring infrastructure
│ ├── personalization/ # Personalization
│ └── ...
│
├── ads-server/ # Advertising / ad-serving service
├── frontend-admin/ # Administration UI
├── database-init/ # PostgreSQL schema and seed data
├── all-data-simulator/ # Synthetic customer data
├── deployments/ # Deployment configuration
├── k8s/ # Kubernetes manifests
├── postgres/ # PostgreSQL image/configuration
├── redis/ # Redis configuration
├── docs/ # Architecture and technical docs
├── ui-wireframes/ # UI design references
│
├── docker-compose.yml
├── dev-docker-compose.yml
├── dev-no-sso-docker-compose.yml
│
├── dev-c360.sh
├── manage-c360.sh
└── run_all_tests.sh
git clone https://github.com/LEO-CDP/leo-customer360.git
cd leo-customer360cp .env.example .envConfigure PostgreSQL, Redis, Keycloak, and service settings in .env.
./dev-c360.shcd customer360-api
./start.shcd ../backend-system/identity_resolution
./run-demo.shcd ../../frontend-admin
./start.sh./manage-c360.sh startCheck service status:
./manage-c360.sh statusRun the consolidated test suite:
./run_all_tests.shFor complete deployment instructions, see the official documentation.
The Customer 360 API is tenant-aware and protected by bearer-token authentication.
Typical authentication flow:
curl -s -X POST \
http://localhost:8008/api/v1/auth/login \
-H 'Content-Type: application/json' \
-d '{
"username": "admin",
"password": "<password from .env>"
}'Use the returned access token for subsequent API requests:
Authorization: Bearer <access_token>Authentication and tenant context are enforced through the API middleware and Keycloak-backed authentication flow.
The complete documentation is available at:
https://leo-cdp.github.io/leo-customer360/
Recommended starting points:
- Architecture
- Customer 360 data model
- Identity Resolution
- API documentation
- Event Tracking API
- Dagster backend
- Docker Compose
- Kubernetes deployment
- Frontend administration
- Database schema
- Testing and troubleshooting
LEO Customer 360 is evolving toward a broader AI-first Customer Data Platform.
- Customer 360 golden records
- Identity Resolution
- Identity graph
- Tenant-aware API
- Event ingestion
- Segmentation
- Analytics infrastructure
- Admin UI
- Production scoring pipelines
- CLV modeling
- Churn prediction
- Lead scoring
- Propensity modeling
- Real-time customer state
- Advanced customer journey intelligence
- AI customer analyst
- Natural-language Customer 360 search
- Text-to-SQL analytics
- Semantic customer discovery
- Customer embeddings
- AI-powered segmentation
- AI recommendation engine
- Agentic marketing workflows
- Campaign orchestration
- Marketing automation
- Personalization engine
- Next-best-action
- Multi-channel activation
- Experimentation and optimization
AI and analytics are only as reliable as the customer identity underneath them.
Bad identity → bad customer intelligence → bad decisions.
Identity resolution is therefore a first-class platform capability.
The system focuses first on building reliable customer context.
Events
+
Profiles
+
Transactions
+
Relationships
+
Identity
+
Context
↓
Customer Intelligence
↓
AI
Identity attributes, matching rules, segmentation metadata, and scoring metadata should be configurable rather than hard-coded wherever practical.
Services should be independently deployable and replaceable.
PostgreSQL, Redis, Dagster, object storage, APIs, and AI services can evolve independently.
Customer intelligence should be traceable.
A unified profile should answer:
- Where did this data come from?
- Which identities were merged?
- Which rule produced the match?
- What confidence did the resolver assign?
- Which system produced the score?
- When was the value updated?
The platform should remain useful without an LLM.
AI should enhance customer intelligence rather than become a dependency for basic identity, data, and analytical operations.
LEO Customer 360 is a core component of the broader LEO CDP ecosystem.
The long-term architecture is:
LEO CDP
│
┌──────────────┴──────────────┐
│ │
DATA FOUNDATION CUSTOMER INTELLIGENCE
│ │
▼ ▼
Data Collection Identity Resolution
Event Tracking Customer 360
Data Pipelines Segmentation
Data Quality Analytics
│ │
└──────────────┬──────────────┘
│
▼
AI LAYER
│
┌────────────┼────────────┐
▼ ▼ ▼
Scoring Prediction Agents
│ │ │
└────────────┼────────────┘
▼
ACTIVATION
│
┌────────────┼────────────┐
▼ ▼ ▼
Marketing Personalization Advertising
The goal is to provide an open, modular foundation for organizations that want to build their own Customer Data Platform rather than depend entirely on a proprietary SaaS stack.
Contributions are welcome.
Areas where contributions are particularly valuable include:
- Identity resolution algorithms
- Data quality
- Customer scoring
- Analytics
- AI / embeddings
- Segmentation
- Personalization
- Campaign orchestration
- Data connectors
- API integrations
- Frontend components
- Documentation
- Testing
Before contributing, review the existing architecture and documentation to understand the service boundaries and data model.
See LICENSE for the license applicable to this repository.
- Documentation: https://leo-cdp.github.io/leo-customer360/
- GitHub: https://github.com/LEO-CDP/leo-customer360
- LEO CDP: https://leocdp.com/