Server definition

Hash: sha256:6ebade222242496225c41d135884ca915d3897c6d5aa5926623afc88ce8ee555
What it is: What a remote MCP server returned when asked what it offers: 22 tools

The blob, as servednamed by its sha256

{
  "instructions": "NLP API suite with 5 text analysis capabilities:\n1. **Toxicity Detection** -- analyze_toxicity scores text for 6 harm categories.\n2. **Sentiment Analysis** -- analyze_sentiment classifies positive/negative tone.\n3. **Named Entity Recognition** -- extract_entities finds persons, orgs, locations.\n4. **PII Detection** -- detect_pii finds and optionally redacts personal information.\n5. **Language Detection** -- detect_language identifies language from 176 supported.\n6. **Translation** -- translate_text translates between 100+ languages.\n7. **Summarization** -- summarize_text (extractive or abstractive).\n8. **Document Q&A** -- answer_question answers using only the supplied text.\n9. **Knowledge base (managed RAG)** -- knowledge_ingest / knowledge_query / knowledge_list_documents.\n10. **Fraud scoring** -- fraud_score scores an event for fraud risk; fraud_feedback records outcomes.\n\nAll tools accept structured inputs and return structured JSON.",
  "tools": [
    {
      "description": "Analyze text sentiment.\n\nReturns positive/negative classification with confidence scores.\nBrainiall Sentiment engine-based with sub-10ms latency. Multiple domain-specific\nmodel variants available.\n\nArgs:\n    text: Text to analyze for sentiment (positive/negative).\n    model: Model variant -- 'general' (default), 'financial', 'twitter'.\n\nReturns:\n    dict with keys:\n        - label (str): 'positive' or 'negative'\n        - score (float 0-1): Confidence score for the predicted label\n        - scores (dict): All label scores (positive, negative)",
      "inputSchema": {
        "properties": {
          "model": {
            "default": "general",
            "description": "Model variant: 'general' (default), 'financial', 'twitter'",
            "type": "string"
          },
          "text": {
            "description": "Text to analyze for sentiment (positive/negative)",
            "maxLength": 100000,
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "analyze_sentiment",
      "outputSchema": null
    },
    {
      "description": "Analyze text for toxic content.\n\nReturns scores for 6 categories: toxic, severe_toxic, obscene, threat,\ninsult, identity_hate. Each score is 0.0-1.0.\nBERT-based classifier with sub-15ms latency on GPU.\n\nArgs:\n    text: Text to analyze for toxicity (hate speech, insults, threats).\n\nReturns:\n    dict with keys:\n        - toxic (float 0-1): Overall toxicity score\n        - severe_toxic (float 0-1): Severe toxicity score\n        - obscene (float 0-1): Obscenity score\n        - threat (float 0-1): Threat score\n        - insult (float 0-1): Insult score\n        - identity_hate (float 0-1): Identity-based hate score\n        - is_toxic (bool): Whether text exceeds toxicity threshold",
      "inputSchema": {
        "properties": {
          "text": {
            "description": "Text to analyze for toxicity (hate speech, insults, threats)",
            "maxLength": 100000,
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "analyze_toxicity",
      "outputSchema": null
    },
    {
      "description": "Answer a question using ONLY the supplied text; returns the supporting sentence(s) with character offsets.\n\nReplies found:false rather than guessing when the answer isn't present in the text.\n\nArgs:\n    text: The text/document to answer from.\n    question: The question to answer.\n\nReturns:\n    dict with keys: answer (str|null), found (bool), supporting_spans (list of {text, start, end}).",
      "inputSchema": {
        "properties": {
          "question": {
            "description": "The question to answer",
            "maxLength": 1000,
            "type": "string"
          },
          "text": {
            "description": "The text/document to answer from",
            "maxLength": 50000,
            "type": "string"
          }
        },
        "required": [
          "text",
          "question"
        ],
        "type": "object"
      },
      "name": "answer_question",
      "outputSchema": null
    },
    {
      "description": "Sentiment per aspect. Brainiall Aspect Sentiment engine.\n\nSplits the text into sentences mentioning each aspect, classifies each, aggregates.",
      "inputSchema": {
        "properties": {
          "aspects": {
            "description": "Aspect terms to score (e.g. ['camera','battery','price'])",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "text": {
            "description": "Input text",
            "type": "string"
          }
        },
        "required": [
          "text",
          "aspects"
        ],
        "type": "object"
      },
      "name": "aspect_sentiment",
      "outputSchema": null
    },
    {
      "description": "Hallucination check: is a claim actually supported by a source text?\n\nBrainiall Groundedness engine. Returns {grounded, confidence, supporting_span, reason}.",
      "inputSchema": {
        "properties": {
          "claim": {
            "description": "The claim to verify",
            "maxLength": 4000,
            "type": "string"
          },
          "source": {
            "description": "The source text the claim should be grounded in",
            "maxLength": 20000,
            "type": "string"
          }
        },
        "required": [
          "claim",
          "source"
        ],
        "type": "object"
      },
      "name": "check_groundedness",
      "outputSchema": null
    },
    {
      "description": "Check health status of NLP API services and loaded models.\n\nReturns:\n    dict with keys:\n        - status (str): 'healthy' or error state\n        - models (dict): Loaded model status per capability\n        - version (str): API version",
      "inputSchema": {
        "properties": {},
        "type": "object"
      },
      "name": "check_nlp_service",
      "outputSchema": null
    },
    {
      "description": "Zero-shot text classification — define your labels at call time. No training, no data upload.\n\nBrainiall Custom Classifier engine. Returns {top_label, scores, confidence}.",
      "inputSchema": {
        "properties": {
          "labels": {
            "description": "Your candidate labels (2-20 of them)",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "multi_label": {
            "default": false,
            "description": "If True, multiple labels can apply",
            "type": "boolean"
          },
          "text": {
            "description": "Input text",
            "type": "string"
          }
        },
        "required": [
          "text",
          "labels"
        ],
        "type": "object"
      },
      "name": "classify_text_custom",
      "outputSchema": null
    },
    {
      "description": "Multi-turn PII detection with cross-turn coreference.\n\nBrainiall Conversational PII engine. Same surface text + type across turns gets the same entity_id.",
      "inputSchema": {
        "properties": {
          "turns": {
            "description": "List of [role, content] dicts representing a dialogue",
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array"
          }
        },
        "required": [
          "turns"
        ],
        "type": "object"
      },
      "name": "detect_conversational_pii",
      "outputSchema": null
    },
    {
      "description": "Detect the language of text.\n\nSupports 176 languages using fastText. Sub-1ms inference latency.\nReturns ISO 639-1 codes with confidence scores.\n\nArgs:\n    text: Text to identify the language of.\n    top_k: Number of top language predictions to return (default: 3).\n\nReturns:\n    dict with keys:\n        - language (str): Top predicted language ISO 639-1 code\n        - confidence (float 0-1): Confidence for top prediction\n        - predictions (list): Top-k predictions, each with:\n            - language (str): ISO 639-1 code\n            - confidence (float 0-1): Prediction confidence",
      "inputSchema": {
        "properties": {
          "text": {
            "description": "Text to identify the language of",
            "maxLength": 100000,
            "type": "string"
          },
          "top_k": {
            "default": 3,
            "description": "Number of top language predictions to return",
            "type": "integer"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "detect_language",
      "outputSchema": null
    },
    {
      "description": "Detect personally identifiable information (PII) in text.\n\nFinds emails, phone numbers, SSNs, credit cards, IP addresses, and\nperson names. Optionally returns redacted text with PII replaced by\ntype labels (e.g. [EMAIL], [PHONE]). BERT-NER + regex ensemble.\n\nArgs:\n    text: Text to scan for personally identifiable information.\n    redact: If true, return redacted text with PII replaced by [TYPE].\n\nReturns:\n    dict with keys:\n        - pii_found (list): Detected PII items, each containing:\n            - text (str): The PII value found\n            - type (str): PII type (EMAIL, PHONE, SSN, CREDIT_CARD, IP, PERSON)\n            - start (int): Character offset start\n            - end (int): Character offset end\n            - score (float 0-1): Detection confidence\n        - count (int): Total PII items found\n        - redacted_text (str|null): Text with PII replaced (when redact=true)\n        - has_pii (bool): Whether any PII was detected",
      "inputSchema": {
        "properties": {
          "redact": {
            "default": false,
            "description": "If true, return redacted text with PII replaced by [TYPE]",
            "type": "boolean"
          },
          "text": {
            "description": "Text to scan for personally identifiable information",
            "maxLength": 100000,
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "detect_pii",
      "outputSchema": null
    },
    {
      "description": "Classify a prompt before it reaches your LLM. Brainiall Prompt Shield engine.\n\nReturns category (jailbreak | prompt_injection | data_exfiltration | impersonation | none),\nseverity, reason, confidence.",
      "inputSchema": {
        "properties": {
          "prompt": {
            "description": "The prompt text to classify (NOT executed)",
            "maxLength": 20000,
            "minLength": 1,
            "type": "string"
          }
        },
        "required": [
          "prompt"
        ],
        "type": "object"
      },
      "name": "detect_prompt_injection",
      "outputSchema": null
    },
    {
      "description": "Detect copyrighted text in user input — famous lyrics, literary openings, proprietary code.\n\nBrainiall Protected Material engine. Returns matched spans with source attribution.",
      "inputSchema": {
        "properties": {
          "text": {
            "description": "Text to scan for copyrighted material",
            "maxLength": 20000,
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "detect_protected_material",
      "outputSchema": null
    },
    {
      "description": "Extract named entities (NER) from text.\n\nIdentifies persons, organizations, locations, and miscellaneous entities\nwith span offsets and confidence scores. BERT-NER based with sub-50ms latency.\n\nArgs:\n    text: Text to extract named entities from.\n\nReturns:\n    dict with keys:\n        - entities (list): Detected entities, each containing:\n            - text (str): Entity text\n            - label (str): Entity type (PER, ORG, LOC, MISC)\n            - start (int): Character offset start\n            - end (int): Character offset end\n            - score (float 0-1): Confidence score\n        - count (int): Total number of entities found",
      "inputSchema": {
        "properties": {
          "text": {
            "description": "Text to extract named entities from (persons, organizations, locations)",
            "maxLength": 100000,
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "extract_entities",
      "outputSchema": null
    },
    {
      "description": "Statistical key-phrase extraction — top-N ranked phrases.\n\nBrainiall Key Phrases engine. Pure-statistical (TF + position + casing + stopword filter), no ML cost.",
      "inputSchema": {
        "properties": {
          "max_ngram": {
            "default": 3,
            "description": "Max words per phrase (1-4)",
            "maximum": 4,
            "minimum": 1,
            "type": "integer"
          },
          "text": {
            "description": "Input text",
            "minLength": 1,
            "type": "string"
          },
          "top_k": {
            "default": 10,
            "description": "Number of phrases to return",
            "maximum": 50,
            "minimum": 1,
            "type": "integer"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "extract_key_phrases",
      "outputSchema": null
    },
    {
      "description": "Report the confirmed outcome of an event so the fraud model can be re-calibrated to your data.\n\nArgs:\n    event_id: The event identifier.\n    label: 'fraud' | 'legitimate' | 'chargeback' | 'dispute'.\n    notes: Optional free-text notes.\n\nReturns:\n    dict with keys: event_id (str), label (str), accepted (bool), feedback_id (int).",
      "inputSchema": {
        "properties": {
          "event_id": {
            "description": "The event_id you passed to fraud_score (or your own identifier)",
            "maxLength": 256,
            "type": "string"
          },
          "label": {
            "description": "The confirmed outcome: 'fraud' | 'legitimate' | 'chargeback' | 'dispute'",
            "type": "string"
          },
          "notes": {
            "anyOf": [
              {
                "maxLength": 2000,
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional free-text notes"
          }
        },
        "required": [
          "event_id",
          "label"
        ],
        "type": "object"
      },
      "name": "fraud_feedback",
      "outputSchema": null
    },
    {
      "description": "Score a transaction or account event for fraud risk. Send whatever signals you have — all optional.\n\nReturns a 0-1 fraud probability, a risk level, the exact risk factors that drove the score (each with its\nweight, direction and a human-readable detail), and a recommended decision (allow|review|deny).\n\nReturns:\n    dict with keys: fraud_probability (float), risk_level (str), decision (str), risk_score_points (float),\n    risk_factors (list of {factor, weight, direction, detail}), decision_bands (dict).",
      "inputSchema": {
        "properties": {
          "account_age_days": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Age of the account in days"
          },
          "amount": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "The transaction amount"
          },
          "avg_txn_amount_30d": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "The account's avg transaction amount over the last 30 days (for amount-anomaly scoring)"
          },
          "avs_match": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Whether the address-verification check matched"
          },
          "card_country": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "ISO country code of the payment instrument"
          },
          "currency": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "ISO 4217 currency code"
          },
          "cvv_provided": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Whether the CVV was provided"
          },
          "distinct_cards_24h": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Distinct cards used on this account in 24h"
          },
          "distinct_countries_24h": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Distinct countries seen on this account in 24h"
          },
          "event_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Your identifier for this event (echoed back; use with fraud_feedback)"
          },
          "ip_country": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "ISO country code geolocated from the IP"
          },
          "is_new_device": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "First time seeing this device"
          },
          "is_new_ip": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "First time seeing this IP"
          },
          "is_proxy_or_vpn": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Request originated from a proxy/VPN/datacenter IP"
          },
          "is_tor": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Request originated from a Tor exit node"
          },
          "prior_chargebacks": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Number of prior chargebacks on this account"
          },
          "txn_count_1h": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Number of transactions on this account in the last hour"
          },
          "txn_count_24h": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Number of transactions on this account in the last 24h"
          }
        },
        "type": "object"
      },
      "name": "fraud_score",
      "outputSchema": null
    },
    {
      "description": "Ingest a document into a knowledge base: it is chunked, embedded and stored for you (managed RAG).\n\nArgs:\n    namespace: The knowledge-base namespace.\n    text: The document text.\n    title: Optional title.\n\nReturns:\n    dict with keys: doc_id (str), n_chunks (int).",
      "inputSchema": {
        "properties": {
          "namespace": {
            "description": "The knowledge-base namespace to ingest into (alphanumeric/hyphen)",
            "maxLength": 128,
            "type": "string"
          },
          "text": {
            "description": "The document text to ingest",
            "maxLength": 200000,
            "type": "string"
          },
          "title": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Optional title for the document"
          }
        },
        "required": [
          "namespace",
          "text"
        ],
        "type": "object"
      },
      "name": "knowledge_ingest",
      "outputSchema": null
    },
    {
      "description": "List the documents stored in a knowledge base (most recent first).\n\nArgs:\n    namespace: The knowledge-base namespace.\n\nReturns:\n    dict with keys: documents (list of {doc_id, title, ...}).",
      "inputSchema": {
        "properties": {
          "namespace": {
            "description": "The knowledge-base namespace",
            "maxLength": 128,
            "type": "string"
          }
        },
        "required": [
          "namespace"
        ],
        "type": "object"
      },
      "name": "knowledge_list_documents",
      "outputSchema": null
    },
    {
      "description": "Retrieve the most relevant passages from a knowledge base plus (optionally) a grounded, cited answer.\n\nReturns found:false rather than a guess when the passages don't contain the answer.\n\nArgs:\n    namespace: The knowledge-base namespace.\n    question: The natural-language question.\n    top_k: How many passages to retrieve.\n    rerank: Re-order retrieved passages before answering.\n    synthesize: Also return a grounded answer.\n\nReturns:\n    dict with keys: answer (str|null), found (bool), passages (list), synthesized (bool), reranked (bool), ...",
      "inputSchema": {
        "properties": {
          "namespace": {
            "description": "The knowledge-base namespace to query",
            "maxLength": 128,
            "type": "string"
          },
          "question": {
            "description": "The natural-language question",
            "maxLength": 2000,
            "type": "string"
          },
          "rerank": {
            "default": false,
            "description": "Re-order the retrieved passages before answering",
            "type": "boolean"
          },
          "synthesize": {
            "default": true,
            "description": "Also return a concise answer grounded only in the retrieved passages",
            "type": "boolean"
          },
          "top_k": {
            "default": 6,
            "description": "How many passages to retrieve",
            "maximum": 50,
            "minimum": 1,
            "type": "integer"
          }
        },
        "required": [
          "namespace",
          "question"
        ],
        "type": "object"
      },
      "name": "knowledge_query",
      "outputSchema": null
    },
    {
      "description": "Named-entity recognition + canonical linking to Wikidata Q-ids.\n\nBrainiall Entity Linker engine. Disambiguates 'Apple' the company from 'apple' the fruit.",
      "inputSchema": {
        "properties": {
          "max_entities": {
            "default": 20,
            "description": "Max entities to return",
            "maximum": 100,
            "minimum": 1,
            "type": "integer"
          },
          "text": {
            "description": "Input text",
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "link_entities_to_wikidata",
      "outputSchema": null
    },
    {
      "description": "Summarize text — extractive (verbatim key sentences in original order) or abstractive (concise rewrite).\n\nArgs:\n    text: The text to summarize.\n    mode: 'abstractive' or 'extractive'.\n    max_length: Target maximum length of the summary, in words.\n\nReturns:\n    dict with the summary (key: summary) plus word/char counts.",
      "inputSchema": {
        "properties": {
          "max_length": {
            "default": 150,
            "description": "Target maximum length of the summary, in words",
            "maximum": 1000,
            "minimum": 10,
            "type": "integer"
          },
          "mode": {
            "default": "abstractive",
            "description": "'abstractive' (concise rewrite) or 'extractive' (most important sentences, verbatim)",
            "type": "string"
          },
          "text": {
            "description": "The text to summarize",
            "maxLength": 50000,
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "summarize_text",
      "outputSchema": null
    },
    {
      "description": "Translate text between 100+ languages.\n\nArgs:\n    text: The text to translate.\n    target_lang: Target language code.\n    source_lang: Source language code; omit to auto-detect.\n\nReturns:\n    dict with the translated text (key: translated_text) and the detected source language if auto-detected.",
      "inputSchema": {
        "properties": {
          "source_lang": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Source language code; omit to auto-detect"
          },
          "target_lang": {
            "description": "Target language code (e.g. 'pt', 'es', 'fr', 'de', 'ja')",
            "type": "string"
          },
          "text": {
            "description": "The text to translate",
            "maxLength": 50000,
            "type": "string"
          }
        },
        "required": [
          "text",
          "target_lang"
        ],
        "type": "object"
      },
      "name": "translate_text",
      "outputSchema": null
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:6ebade222242496225c41d135884ca915d3897c6d5aa5926623afc88ce8ee555 | sha256sum