AI tools

Rough chars-per-token planning from pasted text—CJK-aware heuristic, offline—not provider-exact.

Per-request and monthly spend from token counts and your own per-million rates—local math, no pricing API.

Compare pasted text against 4K–1M context presets—rough token bar, overflow hint, browser-only.

OpenAI-style messages array → per-role rough token table and total—JSON stays local.

User:/Assistant: labeled exports split into turns with rough token share—offline planning.

Normalize spacing on drafts and see rough token reduction—trim only, no rewriting.

Rough words-per-token ratio from pasted text using CJK-aware heuristics.

Token estimate per line with totals—browser-only rough planning.

Rough tokens per paragraph block separated by blank lines.

CJK code-point ratio and suggested chars-per-token for mixed text.

Rough tokens inside Markdown triple-backtick code blocks only.

Compare rough tokens in prose versus fenced code regions.

Mean rough tokens per sentence for readability planning.

Find the heaviest line by rough token estimate.

Estimate rough tokens consumed by empty or whitespace-only lines.

Rough tokens in Markdown # headings versus body text.

Count bullet or numbered list lines and their rough tokens.

Rough tokens tied to http(s) URLs in pasted text.

Rough tokens for JSON-like braced snippets in text.

Count emoji symbols and rough extra token weight.

Share of digits and numeric tokens in pasted text.

Uppercase letter share versus rough total tokens.

Punctuation character count versus rough token total.

Mean character length per whitespace word with token hint.

Rough tokens in repeated identical lines.

Rough tokens in trailing spaces at line ends.

Compare rough tokens in tab-indented versus space-indented lines.

Rough tokens in Markdown > blockquote lines.

Rough tokens inside backtick inline code spans.

Rough tokens in pipe-table rows.

Lines starting with # or // comment markers.

Rough tokens per 100 characters—density planning metric.

Effective chars-per-token for pasted text with CJK blend.

Average UTF-8 byte width per character with token hint.

Rough tokens normalized per KB of UTF-8 bytes.

Whitespace share of characters with rough token context.

Suggest chunk character size from target rough token budget.

Overlap as percentage of chunk size for sliding windows.

Estimate chunk count when splitting on paragraph boundaries.

Group sentences into fixed-size sentence chunks.

Split text into fixed line-count chunks with token estimates.

Number of sliding-window steps for length, chunk, and overlap.

Remaining rough tokens after chunks in a context window.

Divide total token budget evenly across N chunks.

Flag chunks smaller than a minimum character threshold.

How many chars/text exceeds a max chunk size cap.

Count chunks when splitting on a custom delimiter string.

How many fixed-token chunks fit in a context window.

Chunk count for text length with chunk size and overlap.

Estimate chunks from page count and avg chars per page.

Rough duplicate token cost from chunk overlap in a corpus.

Convert per-million price to cost for N thousand tokens.

Project monthly spend from daily tokens and price per million.

Combine input and output token costs at different rates.

Multiply per-request token cost by batch size.

Savings when a fraction of input tokens hit prompt cache.

Max tokens affordable at a fixed dollar budget.

Linear cost projection when users or requests multiply.

Days until free token grant is exhausted at daily usage.

Rough cost for retrieve + generate token bundle.

Convert a token allowance into dollars at a given rate.

Merge consecutive empty lines and show token savings estimate.

Remove trailing spaces on each line with token delta.

Replace curly quotes with ASCII quotes for cleaner prompts.

Remove UTF-8 BOM if present at start of paste.

Normalize paragraph spacing to exactly one blank line.

Join single newlines into flowing prose paragraphs.

Remove image syntax and report token reduction.

Remove HTML tags before sending content to a text model.

Minify pretty-printed JSON-ish text for smaller prompts.

Drop repeated sentences and show token savings.

Sort non-empty lines for diff-friendly prompt prep.

Hard truncate text to a character limit with notice.

Truncate by rough token budget using char heuristic.

Prepend a SYSTEM: block to draft user content.

Append output format instructions to a prompt draft.

Wrap content in named XML tags for structured prompts.

Keep only triple-backtick code blocks from mixed paste.

Remove fenced code and return prose remainder.

Prefix line numbers for review or citation prompts.

Light Markdown cleanup for plain-text model input.

Count User/Assistant/System labeled turns in pasted chat.

Rough tokens in SYSTEM or system: labeled blocks.

Sum rough tokens across user/human labeled turns.

Sum rough tokens in assistant/ai labeled turns.

Count tool: labeled lines in agent transcripts.

Character and UTF-8 byte totals for full transcript.

Mean rough tokens per labeled conversation turn.

Find the heaviest labeled turn by rough tokens.

Tabular turn counts and token sums per role label.

Normalize role labels to User/Assistant/System casing.

Combine adjacent User: blocks into single turns.

List assistant turn paragraphs with token counts.

Rough tokens left for assistant reply given window and paste.

Each turn's percentage of total conversation tokens.

Running cumulative rough tokens across turns.

Rough tokens consumed by JSON object keys versus values.

Split YAML frontmatter token weight from body.

Per-row rough token counts for CSV-like paste.

Show frontmatter and markdown body with token split.

Detect base64 blobs and estimate their token overhead.

Tokens in XML/HTML tag markup versus inner text.

Rough tokens in OpenAPI-ish paths and schema keywords.

Find the top token-heavy lines in log paste.

Count stack trace lines and their token share.

Flag common instruction-override phrases (heuristic only).

Float32 vs float16 byte size for an embedding dimension count.

Bytes for N float32 embedding vectors of D dimensions.

Half-precision storage for N vectors at D dimensions.

Rough cosine-style similarity from shared word overlap on two texts.

Jaccard index on whitespace token sets for two pasted blocks.

Sørensen–Dice coefficient on word sets for two text blocks.

How many API batches for N documents at a given batch size.

L2 norm from space-separated numbers pasted as a vector sample.

Verify two pasted number lists have matching length for dot product.

Gigabytes for N float32 vectors at D dimensions plus rough index overhead.

Cell count and memory hint for N×N similarity matrix.

Flag lines with high word overlap to a reference line.

Simple hash-signature Jaccard estimate for two text blocks.

Storage for int8-quantized vectors with optional scale metadata.

RAM estimate for an in-flight embedding batch (float32).

Average chars and rough tokens per line in source text for embedding.

Rough tokens for keyword query plus vector context snippet.

Count non-empty JSONL training lines and flag parse errors.

Average character length per JSONL row for storage planning.

Rough token sum across all JSONL message content fields.

Suggest train/validation row counts at a given validation ratio.

Rough tokens for one JSONL row pasted as a single example.

Find the heaviest JSONL row by rough token count.

Count blank lines that should be stripped before training.

Count user/assistant/system messages across JSONL rows.

Training steps per epoch from row count, batch size, and epochs.

Compare raw JSONL char count vs minified single-line form.

Compare row count against a minimum examples threshold.

Deterministic shuffle index preview from row count and seed.

Rough tokens per top-level JSON key in one JSONL row.

Rough tokens repeated if the same system prompt appears on every row.

Count rows with more than one user-assistant turn.

Find repeated id or custom_key values across JSONL rows.

Percentage of JSONL rows that parse as valid JSON.

Compare character and rough token counts between reference and candidate outputs.

Word count difference between two model outputs.

Bigram overlap F1-style score between reference and candidate.

Trigram overlap between reference and candidate text.

Rough Flesch reading ease on model output text.

Sentence count delta between two outputs.

Lexical diversity (unique words / total) for an output.

Mean character length per word in model output.

Share of punctuation characters in output text.

Rough token count for a single model output paste.

Percent of reference words found in candidate output.

Line-by-line exact match count between two outputs.

Normalized case-insensitive equality check for two strings.

Longest common subsequence ratio between reference and candidate.

Candidate length as a ratio of reference length.

Longest common subsequence word count between two texts.

Unigram precision BLEU-style score (single reference).

Decoded byte size from a base64 image data URL or raw string.

Base64 encoding overhead vs raw binary size.

Rough vision token estimate from width, height, and patch size.

Duration from byte size and nominal bitrate.

Expected transcript chars from audio minutes and words-per-minute.

Rough character count from pasted PDF extract text.

Estimate pages from total chars and avg chars per page.

Rough tokens if N frames are described as text captions.

Combined rough tokens for screenshot description plus OCR text.

Sum rough tokens for text, image caption, and audio transcript blocks.

Report aspect ratio and whether resize is likely needed.

Expected OCR chars from image megapixels and density heuristic.

Chars and rough tokens if each slide yields N chars of notes.

Rough tokens if table image is described as TSV text.

Stats on a pasted chart description for vision eval.

How many items fit in a batch given per-item token budget and cap.

Quick check if base64 string length implies large binary payload.

Minutes to complete N requests at a requests-per-minute limit.

Time to process total tokens at tokens-per-minute limit.

Wait time from queue depth and average service seconds.

Max batch size from context cap and per-item token estimate.

Safe concurrency from RPM limit and avg request duration.

Max tokens per day from hourly TPM and active hours.

Exponential backoff wait times for N retries.

Suggested wait from Retry-After seconds plus buffer.

Time to embed N documents at embeddings RPM limit.

Requests per minute possible at given avg tokens and TPM.

Compare burst RPM allowance to sustained average over a window.

Max requests in last N seconds at RPS limit.

USD per minute from RPM, avg tokens, and price per 1M tokens.

Total job time from items, batch size, and seconds per batch.

Workers needed to hit target throughput within time budget.

Delay between requests to stay under RPM limit.

Count example blocks separated by --- in a few-shot prompt.

Count {{var}} or {var} placeholders in a prompt template.

Rough tokens added by wrapping content in XML tags.

Token cost of wrapping text in a JSON object envelope.

Rough tokens per role block in a 3-part prompt paste.

Rough tokens and word count for system/instruction block.

Rough tokens per --- separated few-shot block.

Token cost of custom delimiters repeated N times.

Rough tokens per ## section in a Markdown prompt.

Rough tokens in --- YAML frontmatter vs body.

Rough tokens for pasted JSON tool/function schema.

Extra tokens from role tags like <|user|> wrappers.

Combined rough tokens for prefix + body + suffix paste.

Token cost of User:/Assistant: labels on each line block.

Share of tokens in few-shot examples vs instructions.

Replace {{key}} placeholders with values from key=value lines.

Rough token count for pasted MCP or agent-tools JSON manifest.

Char and rough token overhead for a single tool JSON schema block.

Count function or tool entries in a pasted tools array JSON.

UTF-8 byte size of an OpenAPI-style tools or paths JSON snippet.

Combined rough token budget for system prompt and tools JSON separated by ---.

Average and max description length across tools in JSON.

Max nesting depth in a pasted JSON Schema parameters block.

Count required fields across tool parameter schemas in JSON.

Count enum values in nested JSON Schema tool definitions.

Char overhead when repeating server name prefix across tool list.

Line count and non-empty line count for manifest JSON text.

Min, max, and average tool name length from JSON array.

Total property keys across tool parameter objects in JSON.

UTF-8 byte length for integration or manifest URLs (one per line).

Char count for q/qb-style prefill query keys on a sample URL.

Rough tokens for pasted llm-prompt.txt or system instruction file.

Count resource URI strings in MCP-style JSON manifest.

Chars remaining in a memory slot given max chars and current text length.

Ratio of summary length to original conversation chars (blocks separated by ---).

Estimate turns until summarize given current turn and interval N.

Chars kept when sliding window retains last N turns of pasted transcript.

Rough tokens for memory text vs cap number.

Count user/assistant/system turns in pasted chat export.

Count bullet or numbered fact lines in a memory block.

Top-level and nested key count in memory JSON blob.

Chars saved when truncating pasted memory to max length.

Chars over budget for memory + prompt vs max (three --- blocks).

Duplicate line ratio in memory block.

Percent of chars in oldest turn vs full transcript.

Count markdown-style bullets in memory text.

Lines with ISO or time patterns in memory log.

Heuristic count of Capitalized multi-word entity phrases.

Shared boundary chars when merging two memory blocks.

Refreshes remaining given total turns, interval, and done count.

Ratio of common English stopwords in pasted corpus text.

Term frequency percent for a keyword in corpus (text + key field).

Whitespace token count and unique terms in a search query.

Lite TF-IDF score for query terms in corpus (corpus --- query).

Count duplicate chunks by normalized line hash (one chunk per line).

Type-token ratio (unique words / total words) in corpus.

Share of query terms found in corpus (query --- corpus).

Markdown heading lines that could split retrieval chunks.

How many snippets fit in char budget given avg snippet length.

Unique whitespace terms across corpus lines.

Average chars per chunk line in pasted corpus.

Count of adjacent word pairs in query string.

Non-empty line count for line-oriented corpora.

Simple prefix overlap between query and corpus terms.

Terms appearing exactly once in corpus (hapax count).

Percent of corpus lines matched when taking top k by query term hits.

Count explicit chunk separators like --- or ### in corpus.

Ratio of CJK vs Latin letters in bilingual text.

Percent of Cyrillic letters vs all letters.

Count characters in Arabic / Hebrew RTL scripts.

Lines containing both Latin and CJK characters.

Ratio of letters with combining diacritic marks.

Percent of code points in CJK Unified Ideographs range.

Count emoji pictographs in multilingual paste.

Lines using more than one Unicode script category.

Count of distinct script categories present in text.

Count double-brace mustache or indexed brace placeholders.

Lines containing BCP-47 locale tags like en-US.

Count Unicode bidi control characters.

Ratio of fullwidth (FF) vs halfwidth Latin digits/letters.

Percent of letters that are accented Latin.

Count Han ideographs in text.

Count Arabic script letters in text.

Count top-level locale keys in i18n JSON (en, fr, zh-CN).

Heuristic count of email-like patterns (report only—not validation).

Heuristic phone number pattern count in pasted text.

US SSN-like ###-##-#### pattern count (heuristic).

Detect common open-source license header lines at top of file paste.

Count © and (c) copyright markers in text.

Heuristic count of API-key-shaped tokens (sk-, Bearer, etc.).

Count digit groups resembling PAN sequences (heuristic only).

Count IPv4-like dotted quads in text.

Heuristic AKIA access key id pattern count.

Detect PEM private key begin headers in paste.

Count GDPR-related compliance keywords in policy text.

Count PCI-DSS related keywords in compliance text.

Lines with SECRET/PASSWORD/TOKEN in env-style KEY=VALUE paste.

Count JWT-shaped three-part base64url segments.

Count URLs containing user:pass@ pattern.

Detect SPDX license identifiers in text or package metadata.

Count data: lines in pasted Server-Sent Events log.

Avg chars per chunk given total chars and chunk count.

Rough tokens/sec from token count and duration ms.

Valid JSON object lines in newline-delimited JSON stream.

UTF-8 byte size of pasted WebSocket text frame payloads (one per line).

Count event: lines and distinct event names in SSE log.

Count id: fields in SSE stream for reconnection tracking.

Avg ms between chunks from total duration and chunk count.

Count retry: milliseconds fields in SSE headers.

Lines that look like JSON but fail parse (streaming fragments).

SSE comment lines starting with colon.

Avg rough tokens per delta chunk in pasted stream JSON lines.

Characters per second from char count and stream duration ms.

Count data blocks spanning multiple lines (SSE spec).

Avg lines between comment/keep-alive markers.

Non-empty line count as WS text message proxy.

Count markdown ## / ### section headers in a system or user prompt.

Count paired XML-style tags in pasted prompt text.

Count ```json fenced blocks inside a prompt draft.

Count --- separated example blocks in a few-shot prompt.

Count must / required / always constraint keywords in instructions.

Count never / do not / forbidden constraint phrases.

Count hints asking for JSON, markdown, bullets, or tables.

Count user:/assistant:/system: prefixed lines in chat-style prompts.

Count --- or === horizontal rule delimiter lines.

Heuristic count of common imperative verbs in instructions.

Count {{variable}} placeholders in a prompt template.

Estimate maximum XML tag nesting depth in prompt text.

Count # through ###### markdown headings in prompt text.

List languages used in ```lang fenced blocks.

Count numbered list steps (1. 2. etc.) in instructions.

Count lines wrapped in straight or curly quotes as rules.

Count should / shall / recommend positive guidance keywords.

Compare input vs output char length across --- separated examples.

Percent of rough tokens in system vs rest when split by ---.

Count braced JSON-like snippets outside code fences.

Check { } [ ] balance in pasted JSON-like text.

Check comma-separated required keys exist in pasted JSON (key field).

Min/max/avg length of top-level array in JSON.

Count properties under schema.properties in JSON Schema paste.

Maximum object/array nesting depth in parsed JSON.

Count null values recursively in JSON paste.

Average character length of string leaf values in JSON.

Count string/number/boolean/object types in a JSON array.

Count keys at the root object level.

Detect trailing commas before } or ] (invalid strict JSON).

Find repeated keys in shallow JSON object text (regex heuristic).

Ratio of boolean leaf values among all leaves.

Min and max numeric values found recursively in JSON.

Count empty [] arrays nested in JSON.

Count empty {} objects nested in JSON.

Count \\uXXXX escape sequences in JSON text.

Percent of chars that are whitespace in JSON paste.

Percent of keys matching snake_case pattern.

Percent of keys matching camelCase pattern.

Check for common envelope keys data/result/error in object.

Heuristic count of email-like patterns (report-only, not validation).

Heuristic count of phone-number-like digit groups.

Hint when ###-##-#### style SSN patterns appear.

Hint when 13–19 digit card-like groups appear (Luhn not checked).

Count sk- / pk- / api_key= style secret patterns.

Detect Bearer authorization header patterns in pasted text.

Detect BEGIN PRIVATE KEY / RSA PRIVATE KEY blocks.

Detect ghp_ / github_pat_ style token prefixes.

Heuristic hits for classic SQLi phrases in user content.

Count <script> open tags in pasted HTML or markdown.

Detect ignore previous / disregard system style override phrases.

Detect lines pretending to be system: or [SYSTEM] in user paste.

Count dotted IPv4-like quads in text.

Detect user:pass@ in URLs (credential-in-URL pattern).

Count eyJ… three-segment JWT-like tokens.

Flag hex strings ≥32 chars (possible API secrets).

Count [REDACTED] / *** / ███ style redaction markers.

Count [EMAIL] [PHONE] [NAME] style placeholders.

Flag base64-like tokens ≥24 chars (possible secrets).

Combined heuristic risk score from email, key, and injection hints.

How many chunks fit in token budget given avg chunk tokens.

Count [1] (p.12) or [source:file:line] style citation markers.

Chars left after subtracting prompt and retrieved context from cap.

Overlap chars when chunk size and step are given.

Lines in pasted source document for chunk planning.

Estimated chunk count from corpus chars and per-chunk token budget.

Unique [n] citation indices used in answer text.

Percent of max context used by system + RAG + user paste.

Overlap percentage from chunk size and stride.

Chunk count from char length and fixed chunk size.

Average chars per --- separated chunk in paste.

Longest --- separated chunk in pasted pack.

Shortest --- separated chunk in pasted pack.

Size of final partial chunk when splitting by fixed char size.

Rough token estimate for full RAG source paste.

Rough tokens left after packing chunks into window.

Average [n] citations per paragraph in answer.

Count paragraphs as natural chunk boundaries.

Count sentences as fine-grained chunk units.

Steps needed to cover corpus with sliding window.

Percent of reference words found in hypothesis (whitespace tokens).

Hypothesis/reference char length ratio (--- separated).

Whether hypothesis block parses as JSON after --- separator.

Check hypothesis for headings, lists, or code fences.

Rough Flesch reading ease on hypothesis block (English heuristic).

Compare line counts between reference and hypothesis.

Char totals for reference vs hypothesis blocks.

Exact sentence matches between reference and hypothesis.

Jaccard similarity on word sets (reference vs hypothesis).

Lines where hypothesis starts with same prefix as reference line.

Lines sharing same 8-char suffix between ref and hyp.

Compare markdown bullet line counts ref vs hyp.

Compare ``` fence counts reference vs hypothesis.

Count numeric tokens in ref vs hyp.

Count https URLs in reference vs hypothesis.

Percent of ref words found in hyp ignoring case.

Whether hyp equals ref after collapsing whitespace.

Paragraph counts in reference vs hypothesis.

Rough token ratio hypothesis/reference using shared heuristics.

Combined score: JSON valid + bullet count + heading hints.

Turn a token ceiling into a max character plan—same heuristic as token estimate; optional URL ?tokens= & &cpt=.

Count UTF-8 bytes vs JS .length, optional byte budget bar—many HTTP and API limits are octets, not UTF-16 units.

Search and filter 50+ English terms: RAG, embeddings, context window, fine-tuning, guardrails, agents—static text, no model call.

Sliding-window chunk count from length, chunk size, and overlap—numbers only, no upload.

Delimiter-split sections with per-block char counts and rough token share—plan system vs tools vs retrieval locally.

Split a long paste into numbered under-the-limit pieces—paragraph, line, or fixed-width slices—for multi-message chats.

Strip emails, phones, JWTs, Bearer lines, URL creds, and common vendor keys—review output, browser-only.

Report-only finder with line numbers and masked previews—same heuristics as redact, no upload.

Pattern-based checklist for role, task, output format, constraints, and examples—no model call.

YAML frontmatter, ## headings, and length hints for Markdown instruction or rule files—structure only.

Line diff for two pasted drafts—unified view and copy, same engine as plain text diff.

Describe what you want to match in English; get a JavaScript-style pattern, flags, and a short note.

Paste an error message or invalid JSON; get likely causes and fix steps—then check with the formatter.

Paste a diff or change summary; get a suggested Conventional Commits title and optional body.

Paste a diff or summary; get risks, style notes, and questions for review—not a security audit.

Shellexplain-style: paste a bash/sh line or short pipeline; get flags, order, and risk notes in plain English—text only, not executed.

Paste a curl command or raw HTTP request; get parts and risks explained—text only, not sent.

Paste a few lines from app or server logs; get a concise timeline, what stands out, and what to verify next.

Choose formal, casual, shorten, or bullets; rewrite drafts for email, docs, or tickets—review before sending.

From a short topic or page body, draft a page title and meta description in English—review before publishing.

Turn bullet points or a rough outline into short prose paragraphs for docs, tickets, or email.

Translate technical text between English and Simplified Chinese—identifiers and code preserved; human review recommended.

Paste a SELECT or other statement; get clauses, joins, and caveats in plain English—text only, not executed.

Paste a pattern; get a structured breakdown of pieces and flags—pair with natural language → regex or the tester.

Upload JPEG, PNG, WebP, or GIF; get suggested alt text for HTML and accessibility—optional English instructions.

Upload a UI screenshot; get numbered steps to reproduce the flow—optional instructions for goal or audience.

Paste an exception or backtrace; get a structured walk, likely causes, and what to verify next.

Paste .env-style KEY=value lines; get typical meanings and caveats—redact secrets first.

Paste GitHub Actions or GitLab CI YAML; get triggers, jobs, and risks explained—pipelines are not executed.

Paste .pre-commit-config.yaml; get repos, hook IDs, and file filters explained—hooks are not run here.

Paste Kubernetes or Compose YAML; get resources, networking, and volumes explained—no cluster connection.

Paste Chart.yaml, values, or templates; get chart layout and defaults explained—helm is not run here.

Paste a Dockerfile or Containerfile; get multi-stage builds and directives explained—nothing is built on the server.

Paste nginx.conf or site snippets; get locations, upstreams, and TLS explained—configs are not applied here.

Paste .tf HCL; get providers, resources, modules, and variables explained—no terraform plan or apply.

Paste a .service or timer unit; get After=, ExecStart=, and WantedBy= explained—no systemctl or reload.

Paste alert or recording rules YAML; get expr, for, and labels explained—nothing queries your Prometheus.

Paste playbook or task YAML; get plays, modules, and handlers explained—ansible-playbook is not run.

Paste dashboard or panel JSON; get charts, PromQL targets, and variables explained—no Grafana API call.

Paste compose.yaml; get services, networks, volumes, and depends_on explained—compose is not run here.

Paste a Makefile; get targets, variables, and recipes explained—make is not run here.

Paste a Swagger/OpenAPI fragment; get operations, parameters, and responses summarized—no requests sent.

Paste a signature or short code; get test scenarios and edge cases to consider—does not run tests.

Turn bullets or version notes into English README or CHANGELOG Markdown—edit before you ship.