Product
A matching engine you can read, tune and trust.
Cupikernel turns your entities into ranked, explainable matches. Decide how similarity is measured, see exactly why each result scores the way it does, and serve it all through one fast API.
Capabilities
Everything you need to ship precise matching.
Each part of the engine is built to be configured, inspected and run in production.
Similarity kernels
Pick the right similarity measure for each factor.
- Built-in kernels for categorical, set, numeric, geo and semantic data
- Bring your own embeddings or custom scoring functions
- Per-factor normalization keeps scores comparable
Explainable scores
Each result shows the factors behind its score.
- Factor-level contributions on every result
- Readable reason strings you can show in your own UI
- A stable output schema for logging and audits
Rules & constraints
Turn business requirements into explicit logic.
- Hard filters for must-have requirements
- Boosts and penalties for business priorities
- Diversity and exposure controls across result sets
Versioned configuration
Change weights and rules with confidence.
- Every weight and rule change creates a new config version
- Compare versions side by side and A/B test them
- Roll back in one call
Real-time & batch
Results keep up with your data.
- Upserts are matchable within seconds
- Bulk backfills and scheduled batch matching
- Bidirectional queries from either side of a pair
Observability
See how matching behaves in production.
- Latency, throughput and score-distribution metrics
- Per-request traces tagged with the config version
- Webhooks for index and job events
How it computes
How the engine computes similarity.
Every match goes through the same transparent pipeline. Nothing is hidden inside a single opaque model score.
- 01
Entities
Records from both sides of the match, described by your schema.
- 02
Features
Fields are normalized, tokenized or embedded according to their type.
- 03
Kernels
Each factor is scored with its own kernel function k(x, y), from 0 to 1.
- 04
Weighting
Factor scores are combined using the weights in your config.
- 05
Rules
Hard constraints filter results, and boosts adjust their order.
- 06
Results
Ranked matches, each with a score and its contributing factors.
The fit function
fit(a, b) = Σᵢ wᵢ · kᵢ(aᵢ, bᵢ)
where Σᵢ wᵢ = 1 and kᵢ ∈ [0, 1]
subject to rules R(a, b)
Each factor i compares one aspect of two entities with its own kernel, returning a similarity between 0 and 1.
Your config sets the weights, which sum to 1. The overall fit also stays between 0 and 1, and each factor's contribution wᵢ · kᵢ is returned with the result.
Rules run as hard constraints and boosts. They are listed in every response and are never applied silently.
| Kernel | Similarity | Typical use |
|---|---|---|
| Exact / categoricalCategories, flags, required credentials | k(x, y) = 1[x = y] | Categories, flags, required credentials |
| Set overlapSkills, tags, attributes | |X ∩ Y| / |X ∪ Y| | Skills, tags, attributes |
| Numeric (RBF)Years, price, size, level | exp(−(x − y)² / 2σ²) | Years, price, size, level |
| Geo decayDistance, commute, delivery radius | exp(−d(x, y) / λ) | Distance, commute, delivery radius |
| SemanticDescriptions, goals, free text | cos(e(x), e(y)) | Descriptions, goals, free text |
| CustomLogic specific to your domain | your function, sandboxed | Logic specific to your domain |
API & SDKs
Integrate in an afternoon.
A small, predictable REST API with typed SDKs. Send a query entity, get back ranked results with full explanations.
- REST + OpenAPI
- TypeScript
- Python
- Go
- One endpoint to match, one to upsert entities, one to manage configs
- Typed SDKs generated from the same OpenAPI spec
- Test keys with sandboxed indexes for every environment
curl https://api.cupikernel.xyz/v1/match \
-H "Authorization: Bearer $CUPIKERNEL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"index": "talent-prod",
"query": { "type": "role", "id": "role_7f3a" },
"target": "profile",
"config": "hiring-default@v14",
"limit": 3,
"explain": true
}'{
"request_id": "req_01hzx3k9qv",
"config_version": "hiring-default@v14",
"latency_ms": 31,
"results": [
{
"id": "prf_2c91",
"score": 0.92,
"factors": [
{ "name": "skills_overlap", "kernel": "jaccard",
"weight": 0.40, "similarity": 0.96, "contribution": 0.384 },
{ "name": "experience_depth", "kernel": "rbf",
"weight": 0.25, "similarity": 0.88, "contribution": 0.220 },
{ "name": "domain_context", "kernel": "cosine",
"weight": 0.20, "similarity": 0.93, "contribution": 0.186 },
{ "name": "location_schedule", "kernel": "geo_decay",
"weight": 0.15, "similarity": 0.84, "contribution": 0.126 }
],
"rules_applied": [
"require:work_authorization",
"boost:open_to_relocation"
]
},
{ "id": "prf_88ad", "score": 0.87, "factors": [ /* … */ ] },
{ "id": "prf_41f0", "score": 0.81, "factors": [ /* … */ ] }
]
}Performance & reliability
Fast enough for every request, stable enough to build on.
Matching sits on your critical path, so the engine is built for low latency at scale and predictable behavior.
- 01
Low latency
Built to answer within a single request, so matching can sit on your critical path.
- 02
Deterministic
The same inputs and config version always return the same results.
- 03
Safe to retry
Upserts are idempotent, and every endpoint can be retried without side effects.
- 04
Isolated at scale
Indexes scale horizontally and stay separate per environment, with rate limits and quotas on every API key.
Data & privacy
Your data serves your matches, and nothing else.
Privacy is part of the engine's design. You control what is stored, where it lives, what can influence a score and when it is deleted.
- 01
Data minimization
Only the fields your matching configuration needs are stored and processed.
- 02
Field-level controls
Mark sensitive attributes as excluded from scoring so they can never influence a match.
- 03
Encryption
Data is encrypted in transit and at rest, with keys scoped to each environment.
- 04
Regional residency
Choose the region where your indexes and logs live.
- 05
Retention & deletion
Set retention windows and delete records or whole indexes through the API.
- 06
No shared training
Your data is never used to train models shared with other customers.
See your own data through the engine.
Bring a sample of your entities. We'll configure a first set of kernels and weights with you and walk through the explanations together.