# Brainiall NLP

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

- name: com.brainiall/nlp
- version: 1.0.0
- connection class: R0 (autonomous)
- trust: 80/100 flags: no-repository
- quality: 91/100 (strong)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/com.brainiall%2Fnlp
- tools: https://api.protogrid.dev/v1/servers/com.brainiall%2Fnlp/tools

**An agent can connect right now, no human step.** Remote endpoint, no authentication, reachable on the last probe.

## Connection (mcpServers)

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


## Trust

- hygiene: 80
- liveness: 100
- freshness: 85
- provenance: 55
- drivers: +dns-namespace +website +reachable +uptime-100% ~updated-55d-ago -no-repository
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 91/100 (strong)

### protocol: 75 (weight 25)

- warn `protocol.modern`: newest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
- n/a `protocol.stateless`: only applies to 2026-07-28 servers
- pass `protocol.transport`: streamable HTTP
- n/a `protocol.list_ttl`: only applies to 2026-07-28 servers

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 100 (weight 30)

- pass `tools.descriptions`: every tool has a description
- pass `tools.description_length`: descriptions are concise
- pass `tools.schemas`: every tool has an object input schema
- pass `tools.annotations`: 22 of 22 tools declare readOnlyHint or destructiveHint
- pass `tools.directory_hints`: every tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
- pass `tools.token_cost`: about 4,782 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: 100 (weight 15)

- pass `stability.changes`: no tool changes in 30 days
- pass `stability.rug_pull`: no tool changed its meaning under the same name

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: no npm or PyPI package

- tools: 22, about 4,782 tokens to load them all
- tool set hash: 01227389721e06f03433e503d2568919
- badge: [![protogrid quality](https://protogrid.dev/badge/com.brainiall/nlp.svg)](https://protogrid.dev/servers/com.brainiall/nlp)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

_No tool definition changes recorded._

## Remotes

- https://api.brainiall.com/mcp/nlp/mcp (streamable-http, auth none, reachable true, uptime30d 1)

## Packages

_none_

## Tools (22)

- `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)
- `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
- `answer_question`: 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}).
- `aspect_sentiment`: Sentiment per aspect. Brainiall Aspect Sentiment engine.

Splits the text into sentences mentioning each aspect, classifies each, aggregates.
- `check_groundedness`: Hallucination check: is a claim actually supported by a source text?

Brainiall Groundedness engine. Returns {grounded, confidence, supporting_span, reason}.
- `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
- `classify_text_custom`: Zero-shot text classification — define your labels at call time. No training, no data upload.

Brainiall Custom Classifier engine. Returns {top_label, scores, confidence}.
- `detect_conversational_pii`: Multi-turn PII detection with cross-turn coreference.

Brainiall Conversational PII engine. Same surface text + type across turns gets the same entity_id.
- `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
- `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
- `detect_prompt_injection`: Classify a prompt before it reaches your LLM. Brainiall Prompt Shield engine.

Returns category (jailbreak | prompt_injection | data_exfiltration | impersonation | none),
severity, reason, confidence.
- `detect_protected_material`: Detect copyrighted text in user input — famous lyrics, literary openings, proprietary code.

Brainiall Protected Material engine. Returns matched spans with source attribution.
- `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
- `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.
- `fraud_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).
- `fraud_score`: 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).
- `knowledge_ingest`: 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).
- `knowledge_list_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, ...}).
- `knowledge_query`: 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), ...
- `link_entities_to_wikidata`: Named-entity recognition + canonical linking to Wikidata Q-ids.

Brainiall Entity Linker engine. Disambiguates 'Apple' the company from 'apple' the fruit.
- `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.
- `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.