# mcp-contact-classifier [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/mambalabsdev/mcp-contact-classifier  
**GitHub Stars:** 0  
**npm Downloads (last month):** 136  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/mcp-contact-classifier

## Description
Classify a job title into department and seniority, and optionally verify the position.

## Tools
Capabilities this server exposes over MCP:

- **classify_contact** — One contact in, one classified row out. Only the job title is required.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "mcp-contact-classifier": {
    "command": "npx",
    "args": ["-y","@mambalabsdev/mcp-contact-classifier"],
    "env": {
      "APIFY_TOKEN": ""
    }
  }
}
```

**Requires environment variables:** `APIFY_TOKEN` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What mcp-contact-classifier does

The mcp-contact-classifier MCP server wraps Mamba Labs' Contact Classifier actor on Apify. It accepts one contact at a time and returns one classified row. A job title is the only required input for department and seniority classification.

The result includes flat snake_case fields, including a department, seniority, seniority rank, and the rule used for classification. Department and seniority each come from defined sets of 12 values. The rank makes it possible to filter for decision makers with numeric comparisons instead of matching several text labels.

Optional position verification checks whether the supplied person is still listed on the employer's own website. This feature requires both the person's full name and the company's domain. The server does not discover people; names and titles must come from the calling workflow.

## How it works

The server starts an Apify actor run, waits for it to finish, and returns the actor's output. It passes input through as a thin client rather than implementing separate classification behavior locally. Apify errors, invalid inputs, invalid tokens, exhausted balances, timeouts, and unsuccessful runs are returned as explicit tool errors.

Normal classification uses a deterministic rule table. The same title produces the same result, and this path does not call a model or another third-party API. Titles that do not match a rule return null classification values when no LLM key is configured, while the row itself is still returned.

Position verification adds about three seconds and nine requests per contact. The actor run is polled to completion, so verification runs are not limited to a 300-second cutoff.

## Setup and configuration

Install the package with:

```bash
npx -y @mambalabsdev/mcp-contact-classifier
```

Configure the command as an MCP server in the client of your choice. The documented Claude Desktop configuration uses `npx` and supplies an `APIFY_TOKEN`; obtain that token from the Apify account integrations page. Running the server consumes Apify credits and incurs the actor's start and per-contact charges.

The `classify_contact` tool accepts these inputs:

- `job_title` is required and is classified exactly as provided.
- `full_name` and `company_domain` are needed for position verification.
- `verify_position` enables verification and defaults to `false`.
- `use_llm_fallback` enables fallback classification and defaults to `false`.
- `llm_provider` accepts `openai`, `anthropic`, or `google`.
- `llm_model` is passed to the selected provider and defaults to `gpt-4o-mini`.
- `skipCache` bypasses cached results and defaults to `false`.

The optional LLM fallback uses `LLM_API_KEY` on the actor copy. Only the title is sent for that fallback; the person's name is not sent to a language model.

## Tools and capabilities

The mcp-contact-classifier MCP server exposes one MCP tool: `classify_contact`. It classifies a single title, optionally verifies a position against an employer website, supports an LLM fallback for unmatched titles, and can bypass cached results. The output remains one row per contact, including the classification rule for auditability.

The actor charges per classified contact, including contacts whose titles cannot be placed by the rules, plus a small run-start fee. Exact rates depend on the Apify pricing tier and should be checked on the actor's Apify page.

## Limitations and notes

This tool is not a people-discovery service. It cannot find contacts or infer missing names and domains. Position verification checks an employer-published page, so it depends on the supplied identity and company domain.

The server's behavior comes from the Apify actor. An LLM key is not needed for deterministic classification, but unmatched titles remain unclassified without one. The wrapper is MIT licensed.

_Full upstream README: https://allmcps.com/mcp/mcp-contact-classifier/readme_