Skip to content
Cupikernelhome

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.

  1. 01

    Entities

    Records from both sides of the match, described by your schema.

  2. 02

    Features

    Fields are normalized, tokenized or embedded according to their type.

  3. 03

    Kernels

    Each factor is scored with its own kernel function k(x, y), from 0 to 1.

  4. 04

    Weighting

    Factor scores are combined using the weights in your config.

  5. 05

    Rules

    Hard constraints filter results, and boosts adjust their order.

  6. 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.

Built-in kernel functions
KernelSimilarity
Exact / categoricalCategories, flags, required credentialsk(x, y) = 1[x = y]
Set overlapSkills, tags, attributes|X ∩ Y| / |X ∪ Y|
Numeric (RBF)Years, price, size, levelexp(−(x − y)² / 2σ²)
Geo decayDistance, commute, delivery radiusexp(−d(x, y) / λ)
SemanticDescriptions, goals, free textcos(e(x), e(y))
CustomLogic specific to your domainyour function, sandboxed

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
Requestbash
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
  }'
Response · 200 OKjsonc
{
  "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.