# Brainiall NLP (remote · api.brainiall.com)

Sentiment, toxicity, entity extraction, PII, translation, summary, QA, fraud scoring, safety audit.

- Trust score: 87/100 (high trust)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-21

## Components

- remote · `api.brainiall.com`: 87/100 (this document), [markdown](https://verifymcp.io/servers/com-brainiall-nlp/mcp-nlp-mcp.md), [page](https://verifymcp.io/servers/com-brainiall-nlp/mcp-nlp-mcp)

## Channel facts

- Endpoint: `https://api.brainiall.com/mcp/nlp/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-21.

- **Endpoint Security**: 80/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 82/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3196 tokens (~127/item across 25 items; 22 tools + 3 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 87/100
  - Stability observed for 26 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 22 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 24 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Brainiall NLP MCP server?

Brainiall NLP is a hosted endpoint at https://api.brainiall.com/mcp/nlp/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http com-brainiall-nlp 'https://api.brainiall.com/mcp/nlp/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "com-brainiall-nlp": {
      "url": "https://api.brainiall.com/mcp/nlp/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-brainiall-nlp": {
      "type": "http",
      "url": "https://api.brainiall.com/mcp/nlp/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.com-brainiall-nlp]
url = "https://api.brainiall.com/mcp/nlp/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-brainiall-nlp": {
      "type": "remote",
      "url": "https://api.brainiall.com/mcp/nlp/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-brainiall-nlp --url 'https://api.brainiall.com/mcp/nlp/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-brainiall-nlp:
    url: "https://api.brainiall.com/mcp/nlp/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "com-brainiall-nlp": {
      "Transport": "http",
      "Url": "https://api.brainiall.com/mcp/nlp/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-brainiall-nlp -t streamable-http -u 'https://api.brainiall.com/mcp/nlp/mcp'
```

### Other

```json
{
  "mcpServers": {
    "com-brainiall-nlp": {
      "type": "http",
      "url": "https://api.brainiall.com/mcp/nlp/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-21 (score 87, +52)

- [security improvement] Authorization: unverified → partial
- [security improvement] Injection markers: unverified → pass
- [functional regression] Schema quality: unverified → fail
- [functional improvement] Endpoint reachability: not serving MCP → reachable
- [functional improvement] Schema quality: 208 → 127
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Stability: unverified → 0.87
- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

### 2026-09-20 (score 35, −14)

- [security regression] Endpoint reachability: reachable → not serving MCP
- [security regression] Stability: fail → unverified
- [functional regression] Capabilities: pass → unverified

### 2026-09-19 (score 49, 0)

- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

### 2026-09-18 (score 49, −18)

- [security regression] Stability: unverified → fail
- [security improvement] TLS certificate: unverified → pass
- [security improvement] HSTS header: unverified → pass
- [security improvement] Transport: fail → pass
- [security] Authorization: Authorisation not fully verified: no authorisation is required to connect, but we couldn't read the tool list to see what that exposes.
- [functional regression] Schema quality: 127 → 208
- [functional regression] Schema quality: fail → unverified
- [functional improvement] Endpoint reachability: unreachable → reachable
- [functional improvement] MCP protocol: unverified → pass
- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

### 2026-09-17 (score 67, −17)

The score moved with no change recorded against any check. We would rather say so than guess.

### 2026-09-15 (score 84, 0)

- [security regression] Endpoint reachability: reachable → unreachable
- [security regression] Stability: 0.63 → unverified
- [security regression] Authorization: partial → unverified
- [security regression] Tool safety: pass → unverified
- [security regression] TLS certificate: pass → unverified
- [security regression] HSTS header: pass → unverified
- [security regression] Transport: pass → fail
- [functional regression] Schema quality: 100 → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified

### 2026-09-14 (score 84, +1)

No change was recorded against any check on this day. Stability & Change Management went from 60 to 63. That category is still filling its 30-day observation window: 18 days of observed history at the previous scan, 19 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-12 (score 83, +51)

- [security improvement] Authorization: unverified → partial
- [security improvement] Injection markers: unverified → pass
- [security improvement] TLS certificate: unverified → pass
- [security improvement] HSTS header: unverified → pass
- [security improvement] Transport: fail → pass
- [functional improvement] Endpoint reachability: unreachable → reachable
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] Stability: unverified → 0.57
- [functional improvement] MCP protocol: unverified → pass
- [functional] Schema quality: excellent → good

## MCP tools (22)

### `analyze_toxicity` (~212 tokens)

Analyze Toxicity

Analyze text for toxic content.

Returns scores for 6 categories: toxic, severe_toxic, obscene, threat,
insult, identity_hate. Each score is 0.0-1.0.
BERT-based classifier with sub-15ms latency on GPU.

Args:
    text: Text to analyze for toxicity (hate speech, insults, threats).

Returns:
    dict with keys:
        - toxic (float 0-1): Overall toxicity score
        - severe_toxic (float 0-1): Severe toxicity score
        - obscene (float 0-1): Obscenity score
        - threat (float 0-1): Threat score
        - insult (float 0-1): Insult score
        - identity_hate (float 0-1): Identity-based hate score
        - is_toxic (bool): Whether text exceeds toxicity threshold

Input parameters:

- `text` (string, required): Text to analyze for toxicity (hate speech, insults, threats)

### `analyze_sentiment` (~164 tokens)

Analyze Sentiment

Analyze text sentiment.

Returns positive/negative classification with confidence scores.
Brainiall Sentiment engine-based with sub-10ms latency. Multiple domain-specific
model variants available.

Args:
    text: Text to analyze for sentiment (positive/negative).
    model: Model variant -- 'general' (default), 'financial', 'twitter'.

Returns:
    dict with keys:
        - label (str): 'positive' or 'negative'
        - score (float 0-1): Confidence score for the predicted label
        - scores (dict): All label scores (positive, negative)

Input parameters:

- `model` (string): Model variant: 'general' (default), 'financial', 'twitter'
- `text` (string, required): Text to analyze for sentiment (positive/negative)

### `extract_entities` (~172 tokens)

Extract Entities

Extract named entities (NER) from text.

Identifies persons, organizations, locations, and miscellaneous entities
with span offsets and confidence scores. BERT-NER based with sub-50ms latency.

Args:
    text: Text to extract named entities from.

Returns:
    dict with keys:
        - entities (list): Detected entities, each containing:
            - text (str): Entity text
            - label (str): Entity type (PER, ORG, LOC, MISC)
            - start (int): Character offset start
            - end (int): Character offset end
            - score (float 0-1): Confidence score
        - count (int): Total number of entities found

Input parameters:

- `text` (string, required): Text to extract named entities from (persons, organizations, locations)

### `detect_pii` (~277 tokens)

Detect PII

Detect personally identifiable information (PII) in text.

Finds emails, phone numbers, SSNs, credit cards, IP addresses, and
person names. Optionally returns redacted text with PII replaced by
type labels (e.g. [EMAIL], [PHONE]). BERT-NER + regex ensemble.

Args:
    text: Text to scan for personally identifiable information.
    redact: If true, return redacted text with PII replaced by [TYPE].

Returns:
    dict with keys:
        - pii_found (list): Detected PII items, each containing:
            - text (str): The PII value found
            - type (str): PII type (EMAIL, PHONE, SSN, CREDIT_CARD, IP, PERSON)
            - start (int): Character offset start
            - end (int): Character offset end
            - score (float 0-1): Detection confidence
        - count (int): Total PII items found
        - redacted_text (str|null): Text with PII replaced (when redact=true)
        - has_pii (bool): Whether any PII was detected

Input parameters:

- `redact` (boolean): If true, return redacted text with PII replaced by [TYPE]
- `text` (string, required): Text to scan for personally identifiable information

### `detect_language` (~174 tokens)

Detect Language

Detect the language of text.

Supports 176 languages using fastText. Sub-1ms inference latency.
Returns ISO 639-1 codes with confidence scores.

Args:
    text: Text to identify the language of.
    top_k: Number of top language predictions to return (default: 3).

Returns:
    dict with keys:
        - language (str): Top predicted language ISO 639-1 code
        - confidence (float 0-1): Confidence for top prediction
        - predictions (list): Top-k predictions, each with:
            - language (str): ISO 639-1 code
            - confidence (float 0-1): Prediction confidence

Input parameters:

- `text` (string, required): Text to identify the language of
- `top_k` (integer): Number of top language predictions to return

### `check_nlp_service` (~62 tokens)

Check NLP Service

Check health status of NLP API services and loaded models.

Returns:
    dict with keys:
        - status (str): 'healthy' or error state
        - models (dict): Loaded model status per capability
        - version (str): API version

### `translate_text` (~127 tokens)

Translate Text

Translate text between 100+ languages.

Args:
    text: The text to translate.
    target_lang: Target language code.
    source_lang: Source language code; omit to auto-detect.

Returns:
    dict with the translated text (key: translated_text) and the detected source language if auto-detected.

Input parameters:

- `source_lang`: Source language code; omit to auto-detect
- `target_lang` (string, required): Target language code (e.g. 'pt', 'es', 'fr', 'de', 'ja')
- `text` (string, required): The text to translate

### `summarize_text` (~144 tokens)

Summarize Text

Summarize text — extractive (verbatim key sentences in original order) or abstractive (concise rewrite).

Args:
    text: The text to summarize.
    mode: 'abstractive' or 'extractive'.
    max_length: Target maximum length of the summary, in words.

Returns:
    dict with the summary (key: summary) plus word/char counts.

Input parameters:

- `max_length` (integer): Target maximum length of the summary, in words
- `mode` (string): 'abstractive' (concise rewrite) or 'extractive' (most important sentences, verbatim)
- `text` (string, required): The text to summarize

### `answer_question` (~116 tokens)

Answer Question About Text

Answer a question using ONLY the supplied text; returns the supporting sentence(s) with character offsets.

Replies found:false rather than guessing when the answer isn't present in the text.

Args:
    text: The text/document to answer from.
    question: The question to answer.

Returns:
    dict with keys: answer (str|null), found (bool), supporting_spans (list of {text, start, end}).

Input parameters:

- `question` (string, required): The question to answer
- `text` (string, required): The text/document to answer from

### `knowledge_ingest` (~115 tokens)

Ingest Document Into Knowledge Base

Ingest a document into a knowledge base: it is chunked, embedded and stored for you (managed RAG).

Args:
    namespace: The knowledge-base namespace.
    text: The document text.
    title: Optional title.

Returns:
    dict with keys: doc_id (str), n_chunks (int).

Input parameters:

- `namespace` (string, required): The knowledge-base namespace to ingest into (alphanumeric/hyphen)
- `text` (string, required): The document text to ingest
- `title`: Optional title for the document

### `knowledge_query` (~193 tokens)

Query Knowledge Base

Retrieve the most relevant passages from a knowledge base plus (optionally) a grounded, cited answer.

Returns found:false rather than a guess when the passages don't contain the answer.

Args:
    namespace: The knowledge-base namespace.
    question: The natural-language question.
    top_k: How many passages to retrieve.
    rerank: Re-order retrieved passages before answering.
    synthesize: Also return a grounded answer.

Returns:
    dict with keys: answer (str|null), found (bool), passages (list), synthesized (bool), reranked (bool), ...

Input parameters:

- `namespace` (string, required): The knowledge-base namespace to query
- `question` (string, required): The natural-language question
- `rerank` (boolean): Re-order the retrieved passages before answering
- `synthesize` (boolean): Also return a concise answer grounded only in the retrieved passages
- `top_k` (integer): How many passages to retrieve

### `knowledge_list_documents` (~63 tokens)

List Knowledge Base Documents

List the documents stored in a knowledge base (most recent first).

Args:
    namespace: The knowledge-base namespace.

Returns:
    dict with keys: documents (list of {doc_id, title, ...}).

Input parameters:

- `namespace` (string, required): The knowledge-base namespace

### `fraud_score` (~412 tokens)

Score Event For Fraud Risk

Score a transaction or account event for fraud risk. Send whatever signals you have — all optional.

Returns a 0-1 fraud probability, a risk level, the exact risk factors that drove the score (each with its
weight, direction and a human-readable detail), and a recommended decision (allow|review|deny).

Returns:
    dict with keys: fraud_probability (float), risk_level (str), decision (str), risk_score_points (float),
    risk_factors (list of {factor, weight, direction, detail}), decision_bands (dict).

Input parameters:

- `account_age_days`: Age of the account in days
- `amount`: The transaction amount
- `avg_txn_amount_30d`: The account's avg transaction amount over the last 30 days (for amount-anomaly scoring)
- `avs_match`: Whether the address-verification check matched
- `card_country`: ISO country code of the payment instrument
- `currency`: ISO 4217 currency code
- `cvv_provided`: Whether the CVV was provided
- `distinct_cards_24h`: Distinct cards used on this account in 24h
- `distinct_countries_24h`: Distinct countries seen on this account in 24h
- `event_id`: Your identifier for this event (echoed back; use with fraud_feedback)
- `ip_country`: ISO country code geolocated from the IP
- `is_new_device`: First time seeing this device
- `is_new_ip`: First time seeing this IP
- `is_proxy_or_vpn`: Request originated from a proxy/VPN/datacenter IP
- `is_tor`: Request originated from a Tor exit node
- `prior_chargebacks`: Number of prior chargebacks on this account
- `txn_count_1h`: Number of transactions on this account in the last hour
- `txn_count_24h`: Number of transactions on this account in the last 24h

### `fraud_feedback` (~153 tokens)

Report Fraud Outcome (Feedback)

Report the confirmed outcome of an event so the fraud model can be re-calibrated to your data.

Args:
    event_id: The event identifier.
    label: 'fraud' | 'legitimate' | 'chargeback' | 'dispute'.
    notes: Optional free-text notes.

Returns:
    dict with keys: event_id (str), label (str), accepted (bool), feedback_id (int).

Input parameters:

- `event_id` (string, required): The event_id you passed to fraud_score (or your own identifier)
- `label` (string, required): The confirmed outcome: 'fraud' | 'legitimate' | 'chargeback' | 'dispute'
- `notes`: Optional free-text notes

### `extract_key_phrases` (~86 tokens)

Extract Key Phrases

Statistical key-phrase extraction — top-N ranked phrases.

Brainiall Key Phrases engine. Pure-statistical (TF + position + casing + stopword filter), no ML cost.

Input parameters:

- `max_ngram` (integer): Max words per phrase (1-4)
- `text` (string, required): Input text
- `top_k` (integer): Number of phrases to return

### `aspect_sentiment` (~67 tokens)

Per-Aspect Sentiment

Sentiment per aspect. Brainiall Aspect Sentiment engine.

Splits the text into sentences mentioning each aspect, classifies each, aggregates.

Input parameters:

- `aspects` (array, required): Aspect terms to score (e.g. ['camera','battery','price'])
- `text` (string, required): Input text

### `classify_text_custom` (~84 tokens)

Custom Text Classification (zero-shot)

Zero-shot text classification — define your labels at call time. No training, no data upload.

Brainiall Custom Classifier engine. Returns {top_label, scores, confidence}.

Input parameters:

- `labels` (array, required): Your candidate labels (2-20 of them)
- `multi_label` (boolean): If True, multiple labels can apply
- `text` (string, required): Input text

### `link_entities_to_wikidata` (~69 tokens)

Entity Linking (Wikidata)

Named-entity recognition + canonical linking to Wikidata Q-ids.

Brainiall Entity Linker engine. Disambiguates 'Apple' the company from 'apple' the fruit.

Input parameters:

- `max_entities` (integer): Max entities to return
- `text` (string, required): Input text

### `detect_conversational_pii` (~63 tokens)

Conversational PII Detection (multi-turn)

Multi-turn PII detection with cross-turn coreference.

Brainiall Conversational PII engine. Same surface text + type across turns gets the same entity_id.

Input parameters:

- `turns` (array, required): List of [role, content] dicts representing a dialogue

### `detect_prompt_injection` (~69 tokens)

Prompt Shield (Jailbreak / Injection Detection)

Classify a prompt before it reaches your LLM. Brainiall Prompt Shield engine.

Returns category (jailbreak | prompt_injection | data_exfiltration | impersonation | none),
severity, reason, confidence.

Input parameters:

- `prompt` (string, required): The prompt text to classify (NOT executed)

### `check_groundedness` (~71 tokens)

Groundedness Detection (Hallucination Check)

Hallucination check: is a claim actually supported by a source text?

Brainiall Groundedness engine. Returns {grounded, confidence, supporting_span, reason}.

Input parameters:

- `claim` (string, required): The claim to verify
- `source` (string, required): The source text the claim should be grounded in

### `detect_protected_material` (~52 tokens)

Protected Material Detection

Detect copyrighted text in user input — famous lyrics, literary openings, proprietary code.

Brainiall Protected Material engine. Returns matched spans with source attribution.

Input parameters:

- `text` (string, required): Text to scan for copyrighted material

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-brainiall-nlp/mcp-nlp-mcp#diagnostics

## Score history

- 2026-09-21: 87
- 2026-09-20: 35
- 2026-09-19: 49
- 2026-09-18: 49
- 2026-09-17: 67
- 2026-09-16: 84
- 2026-09-15: 84
- 2026-09-14: 84
- 2026-09-13: 83
- 2026-09-12: 83
- 2026-09-11: 32
- 2026-09-10: 48
- 2026-09-09: 64
- 2026-09-08: 80
- 2026-09-07: 80
- 2026-09-06: 80
- 2026-09-05: 79
- 2026-09-04: 79
- 2026-09-03: 79
- 2026-09-02: 78
- 2026-09-01: 78
- 2026-08-31: 77
- 2026-08-30: 77
- 2026-08-29: 76
- 2026-08-28: 76
- 2026-08-27: 75
- 2026-08-26: 75

## Common questions

### What is the Brainiall NLP MCP server?

Brainiall NLP is an MCP server listed in the public MCP registry as com.brainiall/nlp. Sentiment, toxicity, entity extraction, PII, translation, summary, QA, fraud scoring, safety audit. This page covers its hosted endpoint (https://api.brainiall.com/mcp/nlp/mcp).

### Is the Brainiall NLP MCP server safe to use?

Brainiall NLP scores 87 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Brainiall NLP MCP server expose?

Brainiall NLP exposes 22 tools: analyze_toxicity, analyze_sentiment, extract_entities, detect_pii, detect_language, and 17 more. Their descriptions and schemas cost roughly 2,945 tokens of context every time the server is loaded.

### Does the Brainiall NLP MCP server require authentication?

No. We connected to Brainiall NLP without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Brainiall NLP MCP server still maintained?

Brainiall NLP is still listed as active in the MCP registry. We last reached this channel on 21 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://api.brainiall.com/mcp/nlp/mcp
- Website: https://brainiall.com/
- Changelog RSS feed: https://verifymcp.io/servers/com-brainiall-nlp/mcp-nlp-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-brainiall-nlp/mcp-nlp-mcp.json
- HTML version of this page: https://verifymcp.io/servers/com-brainiall-nlp/mcp-nlp-mcp