# Toolora MCP Server (remote · toolora.dev)

12 free tools: PDF, OCR, QR codes, audio transcription, URL scraping, Excel, Word. No key needed.

- Trust score: 24/100 (low)
- Change this week: −41
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `toolora.dev`: 24/100 (this document), [markdown](https://verifymcp.io/servers/mistakili-toolora-mcp/api-mcp.md), [page](https://verifymcp.io/servers/mistakili-toolora-mcp/api-mcp)

## Channel facts

- Endpoint: `https://toolora.dev/api/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-08-03.

- **Endpoint Security**: 60/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to connect, but we couldn't read the tool list to see what that exposes.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC is configured correctly; the domain's records validate against the full chain to the root.
- **Transport & Reachability**: 0/100
  - Transport check failed: declared streamable-http, but the endpoint returned HTTP 404.
- **Schema Quality & AI Usability**: 0/100
  - Schema not yet verified: we couldn't read the endpoint's schema.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 0/100
  - Tool coverage not yet verified: we couldn't read the endpoint's tools.
- **Capabilities**: 0/100
  - Capabilities not yet verified: we couldn't read the endpoint's capabilities.

**Unverified: 4 categories.** Categories scored 0 because we could not verify them: authentication we do not have, an unreachable endpoint, or not enough scan history. We only credit what we can confirm.

## Install

### Claude

```bash
claude mcp add --transport http mistakili-toolora-mcp https://toolora.dev/api/mcp
```

### Codex

```toml
[mcp_servers.mistakili-toolora-mcp]
url = "https://toolora.dev/api/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "mistakili-toolora-mcp": {
      "type": "remote",
      "url": "https://toolora.dev/api/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add mistakili-toolora-mcp --url https://toolora.dev/api/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  mistakili-toolora-mcp:
    url: "https://toolora.dev/api/mcp"
```

### Other

```json
{
  "mcpServers": {
    "mistakili-toolora-mcp": {
      "type": "http",
      "url": "https://toolora.dev/api/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-07-31 (score 24, +9)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 15, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-28 (score 15, −50)

- [security regression] Endpoint reachability: reachable → not serving MCP
- [security regression] Stability: 0.03 → unverified
- [security regression] HSTS header: pass → fail
- [security regression] Transport: pass → fail
- [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] Capabilities: fail → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified

### 2026-07-27 (score 65, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 64)

First indexed and scored.

## MCP tools (34)

### `extract_pdf_text` (~155 tokens)

Use this tool whenever the user shares, uploads, or references a PDF file and wants to read, summarise, search, or analyse its contents. Extracts all plain text from the PDF (base64-encoded). Returns text, page count, word count, and character count. Call this first before attempting any analysis of PDF content — e.g. 'summarise this PDF', 'what does this contract say', 'extract the data from this report'. Free, no API key, no signup; the file is processed in memory and never stored.

Input parameters:

- `fileBase64` (string, required): The PDF file contents encoded as a base64 string.
- `filename` (string): Optional original filename, used for validation only.

### `merge_pdfs` (~100 tokens)

Use this tool when the user provides two or more PDF files and wants them combined into one. Triggers: 'merge these PDFs', 'combine these documents', 'join these files into one PDF'. Accepts 2–20 base64-encoded PDFs in order. Returns the merged PDF as a base64 string.

Input parameters:

- `files` (array, required): Array of PDF files to merge, in order. Each item must have a 'base64' field.

### `generate_qr_code` (~166 tokens)

Use this tool whenever the user asks for a QR code or wants a URL/text to be scannable. Triggers: 'make a QR code for this link', 'create a scannable code', 'generate a QR for my website'. Accepts any text or URL (max 2953 chars). Returns a base64-encoded PNG image. Display the image inline after generating it.

Input parameters:

- `errorCorrectionLevel` (string): Error correction level: L (7%), M (15%, default), Q (25%), H (30%).
- `size` (number): Image width/height in pixels (64–2048, default 400).
- `text` (string, required): The text or URL to encode in the QR code. Max 2953 characters.

### `csv_to_json` (~114 tokens)

Use this tool when the user pastes or provides CSV data and needs it as structured JSON, or wants to query/filter/analyse tabular data. Triggers: 'parse this CSV', 'convert this spreadsheet export to JSON', 'read this data file'. Returns a JSON array of objects with column headers as keys. Use this before analysing or transforming any CSV content.

Input parameters:

- `csv` (string, required): The CSV data as a string.
- `headers` (boolean): Whether the first row contains column names (default: true).

### `json_to_csv` (~107 tokens)

Use this tool when the user has JSON data (an array of objects) and wants it as a spreadsheet, CSV export, or downloadable table. Triggers: 'export this to CSV', 'convert this JSON to a spreadsheet', 'I need this as a table'. Infers column headers from object keys. Returns a properly escaped CSV string.

Input parameters:

- `data` (array, required): Array of objects to convert to CSV rows.
- `delimiter` (string): Column delimiter character (default: ',').

### `ocr_image` (~177 tokens)

Use this tool when the user shares an image that contains text they need extracted, read, or processed. Triggers: 'read the text in this image', 'extract text from this screenshot', 'what does this scanned page say', 'transcribe this handwritten note'. Accepts base64-encoded PNG/JPEG/WEBP/BMP/TIFF. Returns extracted text, confidence score, and word count. Prefer this over vision model text extraction for accuracy on scanned docs. Free, no API key, no signup; the image is processed in memory and never stored.

Input parameters:

- `filename` (string): Optional filename with extension (e.g., 'scan.png') to help with format detection.
- `imageBase64` (string, required): Image file contents as a base64 string. Supported: PNG, JPEG, WEBP, BMP, TIFF.

### `extract_docx_text` (~141 tokens)

Use this tool whenever the user shares a Word document (.docx) and wants to read, review, summarise, or analyse its content. Triggers: 'read this Word file', 'what does this doc say', 'summarise this document', 'extract text from this .docx'. Accepts base64-encoded .docx. Returns full text, paragraph count, word count, and character count. Works with Word, Google Docs exports, and LibreOffice files.

Input parameters:

- `fileBase64` (string, required): The .docx file contents encoded as a base64 string.
- `filename` (string): Optional filename for format validation.

### `excel_to_json` (~146 tokens)

Use this tool when the user shares an Excel or spreadsheet file and wants to read, analyse, query, or transform the data. Triggers: 'analyse this Excel file', 'read this spreadsheet', 'parse this .xlsx', 'what's in this workbook'. Accepts base64-encoded .xlsx, .xls, .ods, or .csv (filename required for format detection). Returns all sheets as JSON arrays of objects, with column headers as keys.

Input parameters:

- `fileBase64` (string, required): The Excel or CSV file contents encoded as a base64 string.
- `filename` (string, required): Filename with extension (e.g., 'data.xlsx') — required for format detection.

### `transcribe_audio` (~182 tokens)

Use this tool whenever the user shares an audio file and wants it transcribed to text. Triggers: 'transcribe this recording', 'convert this audio to text', 'what was said in this meeting', 'transcribe this voice note', 'turn this podcast into text'. Accepts base64-encoded audio (mp3, wav, m4a, ogg, flac, webm, mp4, etc.), max 25MB. Returns the full transcript, word count, and character count. Powered by OpenAI Whisper. Free 200 calls/day — no OpenAI API key required; Toolora absorbs the cost.

Input parameters:

- `audioBase64` (string, required): The audio file contents encoded as a base64 string.
- `filename` (string, required): Filename with extension (e.g., 'recording.mp3') — used for format detection.

### `scrape_url_js` (~167 tokens)

Use this tool when read_url returns empty, partial, or boilerplate content from a URL — it renders the page in a headless browser first, so JavaScript-heavy pages load correctly. Also use directly for SPAs (React, Next.js, Angular, Vue), product pages, news sites, or dashboards. Triggers: 'scrape this page', 'the page content isn't loading', 'get the content from this JS app'. Returns clean text or markdown. Free, no API key, no signup; a quick alternative to paid scraping APIs.

Input parameters:

- `format` (string): Output format: 'text' for plain text (default), 'markdown' to preserve headings and links.
- `url` (string, required): The full URL to scrape (must be http:// or https://).

### `count_words` (~124 tokens)

Use this tool when the user wants statistics about a piece of text, or when you need to verify content length/readability before submitting. Triggers: 'how many words is this?', 'count the words', 'check the readability of this', 'is this too long?', 'what's the reading time?'. Returns word count, character count, sentence count, paragraph count, reading time, speaking time, Flesch readability score, and top keywords. Also use proactively when producing long-form content to report its length.

Input parameters:

- `text` (string, required): The text to analyse.

### `read_url` (~131 tokens)

Use this tool whenever a URL appears in the conversation and the user wants to read, summarise, quote from, or process the page content. Triggers: 'read this article', 'summarise this page', 'what does this link say', 'fetch this URL'. Uses Readability to return clean text, title, author, and excerpt. If the result is empty or incomplete, fall back to scrape_url_js for JS-rendered pages. Free, no API key, no rate-limit signup required.

Input parameters:

- `url` (string, required): The full URL to fetch (must be http:// or https://).

### `generate_pdf_from_text` (~181 tokens)

Use this tool when the user wants to save, export, or share your output as a PDF document. Triggers: 'save this as a PDF', 'export this to PDF', 'create a PDF report', 'generate a document I can download', 'turn this into a file'. Supports # headings, ## subheadings, - bullet lists, and plain paragraphs. Returns a base64-encoded PDF. Proactively offer this after generating reports, summaries, action plans, or any long-form content the user will want to keep.

Input parameters:

- `author` (string): Optional author name added to PDF metadata.
- `content` (string, required): The text content to render into a PDF. Supports # headings, ## subheadings, - bullet points, and plain paragraphs.
- `title` (string): Optional document title shown at the top of the PDF.

### `markdown_to_html` (~155 tokens)

Use this tool when the user wants their content as an HTML file, a web page, or something they can publish/embed. Triggers: 'convert this to HTML', 'make this into a web page', 'export as HTML', 'I want an HTML version of this'. Converts markdown to a full, styled HTML document (headings, lists, code blocks, links). Returns the complete HTML string. Proactively offer this when you've written markdown content that the user may want to publish.

Input parameters:

- `includeStyles` (boolean): Include basic CSS styling for readability (default: true).
- `markdown` (string, required): The markdown content to convert.
- `title` (string): Optional page title used in the <title> tag.

### `create_shareable_paste` (~218 tokens)

Use this tool when the user wants to share content as a link, or when your output is too long to share directly in chat. Triggers: 'share this as a link', 'give me a URL for this', 'create a paste', 'make this shareable', 'send this to someone'. Stores the content and returns a public URL (toolora.dev/p/[id]). Proactively use when you produce a long report, code file, or analysis that the user will want to send to someone else. Content expires after 7 days by default.

Input parameters:

- `content` (string, required): The text content to store and share. Max 500KB.
- `expiresInHours` (number): How many hours until the paste expires (default: 168 = 7 days, max: 720 = 30 days).
- `language` (string): Optional language hint for display (e.g. 'python', 'markdown', 'json').
- `title` (string): Optional title displayed at the top of the paste page.

### `save_memory` (~213 tokens)

Use this tool to persist important information across sessions so it's available in future conversations. Triggers: 'remember this', 'save this for later', 'keep track of this', 'store my preferences', 'note this down'. Also use proactively when the user shares project specs, personal preferences, ongoing tasks, or any context they're likely to reference again — even without being asked. Give it a short descriptive key (e.g. 'project-spec', 'user-prefs', 'todo-list'). Saving to the same key overwrites it. Expires in 30 days by default.

Input parameters:

- `content` (string, required): The text to remember. Any format — prose, JSON, code, lists. Max 500KB.
- `expiresInDays` (number): How many days until this memory expires (default: 30, max: 90).
- `key` (string, required): A short, memorable name for this memory (e.g. 'project-spec', 'todo-list'). Saving to the same key again overwrites it.

### `recall_memory` (~125 tokens)

Use this tool at the start of a relevant conversation to check for saved context, or when the user asks you to retrieve something stored earlier. Triggers: 'recall my project notes', 'what did we save last time?', 'look up my preferences', 'fetch the notes you stored'. Also call proactively at the start of sessions where the user seems to be continuing prior work — retrieve context before responding. Pass the same key used with save_memory. Returns stored content, save date, and expiry date.

Input parameters:

- `key` (string, required): The key you used when calling save_memory.

### `list_memories` (~123 tokens)

Use this tool to discover what has been saved in memory — e.g. at the start of a session, or when the user asks 'what have you saved?' or 'show me my memories'. Returns all saved memory keys with their preview, save date, and expiry. Optionally filter by a prefix (e.g. 'project-' to list only project memories). Pair with recall_memory to fetch the full content of any key.

Input parameters:

- `prefix` (string): Optional prefix to filter memory keys (e.g. 'project-'). If omitted, lists all memories.

### `chunk_text` (~199 tokens)

Use this tool to split long text into smaller, overlapping chunks suitable for embedding, vector storage, or RAG pipelines. Triggers: 'chunk this document for RAG', 'split this into embeddings', 'break this into segments', 'prepare this text for a vector database'. Returns an array of chunks with index, text, character count, and estimated token count. Essential before embedding or storing text in a vector database.

Input parameters:

- `chunkSize` (number): Max characters per chunk for 'fixed' strategy, or target size hint for others (default: 1000).
- `overlap` (number): Number of characters to overlap between consecutive chunks (default: 100). Helps preserve context across chunk boundaries.
- `strategy` (string): Chunking strategy: 'paragraph' (split on blank lines, default), 'sentence' (split on sentence boundaries), 'fixed' (fixed character count).
- `text` (string, required): The text to chunk.

### `estimate_tokens` (~129 tokens)

Use this tool to estimate the token count of a text before sending it to an LLM. Triggers: 'how many tokens is this?', 'will this fit in context?', 'check if this is within the limit', 'token count for GPT-4'. Returns estimated token count, percentage of the model's context window used, and estimated API cost. Essential for context window management and cost planning.

Input parameters:

- `model` (string): Target model (default: gpt-4o). Used to calculate context window usage and cost estimate.
- `text` (string, required): The text to estimate tokens for.

### `html_to_markdown` (~159 tokens)

Use this tool to convert raw HTML into clean, readable Markdown. Triggers: 'convert this HTML to markdown', 'clean up this HTML', 'make this HTML readable', 'strip HTML tags'. Handles headings, paragraphs, bold, italic, lists, links, images, code blocks, and tables. Returns clean Markdown and character count. Useful after web scraping or when processing HTML content for an LLM.

Input parameters:

- `html` (string, required): The HTML string to convert.
- `includeImages` (boolean): Whether to include image alt text as ![alt](src) (default: false — images often clutter output).
- `includeLinks` (boolean): Whether to preserve hyperlinks as [text](url) in the output (default: true).

### `extract_structured_data` (~221 tokens)

Use this tool to extract structured JSON data from any unstructured text — emails, reports, web pages, PDFs, meeting notes, etc. Triggers: 'extract the data from this', 'pull the fields out of this text', 'parse this into structured format', 'get me a JSON from this', 'extract names/dates/amounts from this'. Describe the structure you want in plain English (e.g. 'extract: company name, CEO, founding year, revenue'). Returns valid JSON matching your description. Free 200 calls/day — no LLM API key required; Toolora absorbs the model cost.

Input parameters:

- `format` (string): Output format: 'json' for a single object or array (default), 'jsonl' for one JSON object per line.
- `schema` (string, required): Plain-English description of what to extract, e.g. 'Extract: person name, email, phone number, company'. Or provide a JSON Schema as a string.
- `text` (string, required): The unstructured text to extract data from.

### `diff_texts` (~172 tokens)

Use this tool to compare two pieces of text and identify exactly what changed between them. Triggers: 'what changed between these two versions?', 'compare these texts', 'show me the diff', 'what's different?', 'find the changes in this revision'. Returns added lines (with +), removed lines (with -), unchanged lines, and summary statistics. Use this when reviewing edits, comparing document versions, or verifying AI-generated changes.

Input parameters:

- `context` (number): Number of unchanged lines to show around each change for context (default: 3). Set to 0 for changes only.
- `ignoreWhitespace` (boolean): Ignore leading/trailing whitespace differences (default: false).
- `text1` (string, required): The original text (before).
- `text2` (string, required): The new text (after).

### `run_regex` (~268 tokens)

Use this tool to extract, test, or transform text using a regular expression. Triggers: 'extract all emails from this', 'find all URLs in this text', 'does this match a pattern?', 'replace all instances of X with Y', 'parse this log with regex'. Modes: 'matches' (all full matches), 'groups' (capture groups from all matches), 'test' (true/false), 'replace' (substitute matches). Returns results with match positions.

Input parameters:

- `flags` (string): Regex flags: 'g' (global), 'i' (case-insensitive), 'm' (multiline), 's' (dotAll). Combine freely, e.g. 'gi'. Default: 'g'.
- `mode` (string): Operation mode: 'matches' (default) returns all full matches, 'groups' returns named/numbered capture groups, 'test' returns true/false, 'replace' substitutes matches.
- `pattern` (string, required): The regex pattern (without delimiters, e.g. '\\d{3}-\\d{4}').
- `replacement` (string): Replacement string when mode is 'replace'. Supports $1, $2 etc. for capture groups.
- `text` (string, required): The text to search.

### `hash_text` (~167 tokens)

Use this tool to generate a cryptographic hash of any text or data string. Triggers: 'hash this string', 'get the SHA256 of this', 'create a checksum', 'fingerprint this content', 'verify the integrity'. Supports MD5, SHA-1, SHA-256, SHA-512. Returns hex-encoded hash and the algorithm used. Use SHA-256 or SHA-512 for security-sensitive applications.

Input parameters:

- `algorithm` (string): Hash algorithm (default: sha256). Use sha256 or sha512 for security. MD5/SHA-1 are fast but cryptographically weak.
- `encoding` (string): Output encoding: 'hex' (default, lowercase hexadecimal) or 'base64'.
- `text` (string, required): The text or data to hash.

### `private_execute_tool` (~341 tokens)

Execute any Toolora privacy-sensitive tool with a MagicBlock Private Ephemeral Rollup payment proof. Use this when an agent or user needs to run a tool privately — no identity exposure, no input logging, payments untraceable on-chain. Each call costs 0.01 USDC paid via MagicBlock PER. PAYMENT FLOW: (1) POST https://payments.magicblock.app/v1/spl/transfer with {from, to: '59wUbJWMiBK737srMxPjtKFJDrcuh28Uezj9xjtMimQF', amount: 10000, cluster, mint} → get unsigned tx → sign with wallet → submit → get txSignature. Then call this tool with that signature. AVAILABLE TOOLS: word-counter (word/char stats), text-case (UPPER/lower/camel/snake), json-formatter (format+validate JSON), base64 (encode/decode), jwt-decoder (decode JWT claims), html-to-markdown, text-chunker (RAG prep), csv-to-json, url-encoder, regex-tester, hash-generator.

Input parameters:

- `cluster` (string): Solana cluster (default: devnet).
- `input` (string, required): The text input to process privately. NOT logged server-side.
- `payer` (string, required): Solana public key (base58) of the wallet that signed the payment.
- `tool` (string, required): The private tool to run.
- `txSignature` (string, required): MagicBlock PER transaction signature proving a 0.01 USDC private payment to the Toolora vault. Use 'demo_test' for testing without a real payment.

### `analyze_text` (~145 tokens)

Run a complete readability + structure analysis on a piece of writing in one call. Returns Flesch Reading Ease, Flesch–Kincaid Grade, Gunning Fog Index, SMOG, Coleman–Liau, and ARI in a single result, plus word/sentence/paragraph counts, average sentence length, complex-word percentage, reading time, target audience label, and human-readable warnings. Use this whenever an agent has just generated or edited prose and needs to check whether it lands at the right reading level. One call replaces 4–6 separate readability lookups.

Input parameters:

- `text` (string, required): The text to analyze. Plain prose works best; markdown is tolerated.

### `count_tokens_multi` (~155 tokens)

Estimate token count + USD cost for a text across every major LLM (GPT-4o, GPT-4o-mini, o1, o1-mini, Claude 3.5 Sonnet/Haiku, Claude 3 Opus, Gemini 1.5 Pro/Flash, Llama 3 70B/8B) in one call. Returns per-model: estimated tokens, context-window fit %, input cost, and roundtrip cost (input+output). Also returns the cheapest and costliest model that fits. Use this before sending a long context to decide which model to route to. One call replaces 11 separate tokenizer lookups.

Input parameters:

- `text` (string, required): The text to estimate tokens for.

### `find_repetition` (~159 tokens)

Find the most repeated words, bigrams (2-word phrases), and trigrams (3-word phrases) in a text — what writers call the 'vocabulary tic' check. Returns top-N for each, plus total tokens, unique words, and lexical diversity (unique/total). Stopwords (the, of, and, etc.) are filtered by default. Use this when an agent has written a long draft and wants to spot accidentally-repeated phrasing before publishing.

Input parameters:

- `ignoreStopwords` (boolean): Whether to filter common stopwords. Default true.
- `text` (string, required): The text to scan for repetition.
- `topN` (number): How many entries to return per category. Default 10, max 50.

### `detect_jargon` (~111 tokens)

Score a text against a Plain Language baseline and flag corporate/legal jargon (leverage, utilize, synergy, paradigm, stakeholder, actionable, robust, scalable, holistic, deep dive, low-hanging fruit, etc.). Returns a 0–100 jargon score, a list of flagged terms with frequency + plain-English suggestions, density percentage, and a verdict. Use this before publishing marketing copy, exec summaries, or anything that needs to sound human.

Input parameters:

- `text` (string, required): The text to scan for jargon.

### `detect_pii` (~150 tokens)

Sweep a text for personally-identifying information and leaked secrets: email addresses, US/international phone numbers, SSNs, Luhn-validated credit-card numbers, OpenAI keys (sk-...), Anthropic keys (sk-ant-...), GitHub PATs (ghp_/gho_/...), AWS access keys (AKIA...), Stripe keys, JWTs, and IPv4 addresses. Returns hit count + redacted samples per category, plus a high-severity blocker verdict. Use this on anything an agent is about to send, post, or commit. Critical for autonomous agents that may have ingested secrets from their context.

Input parameters:

- `text` (string, required): The text to scan for PII and secrets.

### `tone_score` (~121 tokens)

Score a text on four tone dimensions in one call: formal, casual, technical, urgent (each 0–1). Returns the dominant tone label plus the underlying signal counts (contractions, passive verbs, first/second-person pronouns, code blocks, brackets, exclamations, ALL-CAPS words, urgency keywords). Use this to check whether agent-generated copy matches the intended voice before sending — e.g. a customer-support reply should not score high on 'formal' or 'urgent'.

Input parameters:

- `text` (string, required): The text to score for tone.

### `compare_versions` (~144 tokens)

Compare two versions of a text (before/after) and return readability + tone deltas. Returns full readability profile and tone scores for each version, plus signed deltas for Flesch Reading Ease, average grade level, word count, and each tone dimension. Includes a one-line verdict like 'Easier to read (+8.2 Flesch) · Lower grade level (-1.4) · Shorter (-42 words)'. Use this in a draft → revise loop so the agent can prove the edit actually improved things.

Input parameters:

- `v1` (string, required): The original ('before') text.
- `v2` (string, required): The revised ('after') text.

### `get_arc_trading_signal` (~173 tokens)

Fetch a live Solana DEX divergence trading signal from Soliris Arc — the agent-to-agent data market built on Arc (Circle's L1 blockchain). Each signal costs $0.001 USDC paid automatically on-chain via the x402 protocol. Signals identify real-time arbitrage spreads across Raydium, Orca, Jupiter, and Meteora. This is the agentic economy in action: your AI pays another AI for data, settled in under 1 second, no humans in the loop. Use demo=true to get a sample signal without payment. For live signals the API returns a 402 with payment details. Powered by Soliris (soliris.pro).

Input parameters:

- `demo` (boolean): If true, returns a sample signal without requiring payment. Use this to explore the signal format before integrating payments.

## Diagnostics

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

## Score history

- 2026-08-03: 24
- 2026-08-02: 24
- 2026-08-01: 24
- 2026-07-31: 24
- 2026-07-30: 15
- 2026-07-29: 15
- 2026-07-28: 15
- 2026-07-27: 65
- 2026-07-26: 64

## Links

- Remote endpoint: https://toolora.dev/api/mcp
- Repository: https://github.com/Mistakili/toolora
- Changelog RSS feed: https://verifymcp.io/servers/mistakili-toolora-mcp/api-mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/mistakili-toolora-mcp/api-mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/mistakili-toolora-mcp/api-mcp