About Showcase Testing MCP Features Pricing Install
Instagram

Prune any log using one command.

Designed for AI agents. Collapse noise, rank relevance, pack to budget — before Claude ever sees it.

INSTALL ROKA

Install the local roka CLI — detects OS and architecture automatically.

Connect Roka MCP to your AI agent in one command.

Get Started Free Read the Docs See it work →

// 48,204 lines ingested · −94% noise removed · 312ms

Log compaction

500 identical errors. One line in context.

Roka fingerprints repetitive patterns across your entire log file — UUIDs, timestamps, and stack frames collapse into provenance headers. The agent sees what happened, not 500 copies of it.

ERROR [worker] connection refused
× 500 identical lines …
roka pruning …
[500x | lines 240–740] ERROR [worker] connection refused
−99.8% repetition · 1 line in context
ERROR ×500 → 1 line
Crash → context

Your dev server crashes. Your agent already knows.

roka-mcp watches dev.log in real time. On crash it prunes 12,400 lines down to 1.1K tokens and hands Claude Code exactly the slice it needs — no copy-paste, no blown context window.

🔴 ERROR [worker] connection refused
pruning 12,400 lines → 1.1K tokens
✓ handed to Claude Code
Natural language

Ask in plain English. Get ranked output.

Type what you care about — "what broke during last night's deploy?" — and Roka re-ranks chunks against intent, not just keywords. Semantic re-ranking surfaces the fatal error first.

"what broke during last night's deploy?"
INFO [startup] Application started
ERROR [Database] FATAL: Connection reset ↑ #1
INFO [Cache] Cache miss key: session_123

same logs. smarter context.

Why Roka beats just uploading to Claude directly.

Feature roka Upload to Claude Semantic Search
No file size limit ✓ — (100MB max) ✓
Logs never leave your machine ✓ — —
90% token reduction ✓ — — (partial)
312ms processing ✓ — (10s+) —
Critical error always preserved ✓ — —
Collapses repeated log patterns ✓ — —
Works offline ✓ — —
Price Free / $20 Pro Pay per token Complex setup
Universal context layer

Roka connects to any AI agent

One command. Same pruning pipeline, any IDE or chat interface.

Roka roka
Claude
Claude Code
Cursor
Cursor
ChatGPT
ChatGPT
GitHub Copilot
GitHub Copilot
Gemini
Google Gemini
Any LLM / stdout

Hover the icons to see agent names · one command to connect:

npx roka-mcp connect --agent <claude-code | cursor | codex | …>
If you use Claude Code or Cursor — read this Pro

Your dev server crashes. Your agent already has the fix in context.

Roka runs as an MCP server next to your local dev server, watching logs in real time. The moment something crashes, it runs the same prune pipeline — collapse repetition, preserve the exception, rank, pack to budget — and hands Claude Code or Cursor exactly the slice of context needed to debug. No copy-pasting stack traces. No blowing the context window on thousands of lines of noise.

Works with Claude Code Works with Cursor One command to connect Auto-prunes on crash
crash detected · roka-mcp pruning
// before: 12,400 lines of connection errors
ERROR [worker] connection refused
ERROR [worker] connection refused
ERROR [worker] connection refused
… 497 more identical lines …
// after: pruned output
[500x | lines 240–740] ERROR [worker] connection refused
Compressed: ERROR ×500 → 1 line
One-click MCP install

Pro feature · see pricing

See it happen

Four moments that define Roka — noise to signal, crash to fix, install to debug.

Log compaction
WARN [db_pool] Connection pool 85%, retry 50ms
WARN [db_pool] Connection pool 85%, retry 50ms
WARN [db_pool] Connection pool 85%, retry 50ms
WARN [db_pool] Connection pool 85%, retry 50ms
WARN [db_pool] Connection pool 85%, retry 50ms
WARN [db_pool] Connection pool 85%, retry 50ms
… 841 more …
[847x] WARN [db_pool] Connection pool 85%, retry 50ms
[847x] WARN [db_pool] Connection pool 85%, retry 50ms
847 repetitive lines → 1 ranked chunk
Crash → prune → handoff
🔴 ERROR [worker] connection refused
pruning 12,400 lines → 1.1K tokens
✓ handed to Claude Code
🔴 crash detected
pruning 12,400 lines → 1.1K tokens
✓ handed to Claude Code
One-click MCP install
$ npx roka-mcp connect --agent claude-code
✓ detected Claude Code config
✓ installed MCP server
✓ watching ./logs/dev.log
$ npx roka-mcp connect --agent claude-code
✓ roka-mcp ready on stdio
Natural language query
"what broke during last night's deploy?"
INFO [startup] Application started
ERROR [Database] FATAL: Connection reset
INFO [Cache] Cache miss key: session_123
"what broke during last night's deploy?"
ERROR [Database] FATAL: Connection reset ↑ ranked #1

Built for real context, not toy demos

Roka is a pruning middleware: ingest logs, code, or prose, detect structure, score relevance to your query, and deliver exactly what fits the budget.

01

Log compaction

Fingerprints repetitive lines (UUIDs, IPs, timestamps → placeholders) and collapses patterns above a threshold into summary chunks with provenance.

02

Critical preservation

Panics, exceptions, OOM, auth failures, and stack traces are never collapsed — always packed first regardless of score.

03

BM25 + semantic rank

Fast lexical scoring with BM25Okapi, then optional sentence-transformer re-ranking so chunks match your query intent.

04

Token budget packer

Greedy packing with exact tiktoken counts (cl100k_base). Source diversity cap prevents one file from hogging the budget.

05

Multi-format input

Auto-detects logs, code, or prose. Code can be minified (docstrings/comments stripped) and chunked by function/class scope.

06

API & CLI

Pipe stdin, point at a file, or POST to /api/prune. Same pipeline everywhere — stdout is always the pruned context.

07

Natural language queries

Ask in plain English what you care about — Roka ranks chunks against intent, not just keywords.

CLI on GitHub MCP on GitHub All repos

Use Cases

Beyond logs — Roka optimizes context for incident investigation, RAG pipelines, and code review at scale.

Incident Investigation

Compress incident dumps and error traces into AI-ready summaries.

  • → Collapse redundant stack traces and log repetition
  • → Preserve critical error context and panic messages
  • → Feed compressed incident timeline to Claude for root cause analysis

RAG & Knowledge Base Optimization

Prune your document corpus before ingesting into retrieval pipelines.

  • → Strip boilerplate, comments, and redundant sections from code files
  • → Collapse similar documents and de-duplicate content
  • → Pack only high-relevance chunks into your vector index

Code Review at Scale

Review massive pull requests by compressing diff context.

  • → Strip whitespace and reformatting noise from diffs
  • → Collapse repetitive changes across similar files
  • → Summarize only the critical logic changes for faster review
Real benchmark — LogHub corpus

Tested on real production logs, not a cherry-picked demo

We ran the exact prune_file / prune_logs tools shipped in Roka's MCP server against LogHub — the standard academic corpus used in log-parsing research. 15 real systems, one 4,000-character budget, zero per-file tuning.

Key Metrics
92.2%
Avg. lines removed (dedup + budget-fit) across 15 real log sources
69×
Avg. compression ratio — 276K chars in → 4K chars out, per file
11 / 11
Log sources with real errors that still surfaced after pruning
Log Compression — % lines removed Hover to inspect

LogHub production datasets · dedup + 4,000-char budget fit, sorted low → high

100%80%60%40%20%0%
72.7%
74.4%
74.5%
92.0%
92.4%
95.5%
96.0%
97.2%
97.6%
97.8%
98.0%
98.3%
98.6%
98.7%
99.0%
BGLHPCApacheHadoopMacProxifierHDFSLinuxOpenSSHSparkHealthAppAndroidThunderbirdWindowsOpenStack
OpenStack (cloud infra) 99.0%
Methodology
  • → Corpus: LogHub — 15 real system/production log sources, ~2,000 raw lines each (30,001 lines / 4.15M characters total).
  • → Same tool, same rules, no per-file tuning: MCP prune_file, default 4,000-character budget.
  • → Rule: collapse consecutive duplicate lines, force-keep lines matching ERROR|FATAL|CRITICAL|Exception|Traceback|panic.
  • → Verified by hand: for every source that contained a real error, at least one verbatim error line survived into the final output.
Live test — Without Roka vs. With Roka

Same file, same 4,000-character budget, two strategies. Testing/Thunderbird_2k.log — 2,000 lines, 323,193 characters. The real failure — sshd: Bind to port 22 ... Address already in use — sits 62% into the file, squarely "lost in the middle."

Without Roka
naive tail -c 4000		 With Roka
prune_file
Lines sent to LLM 27 28
Characters sent 4,000 4,000
~Tokens (chars ÷ 4) ~1,000 ~1,000
"Bind to port 22" found? No — 0 matches Yes — kept

Same budget, same token cost — but the naive tail only carries ntpd: synchronized and gmetad: data_thread() monitoring noise. Verified live via the MCP prune_file tool, not simulated.

Full methodology, raw data, and a deeper look at context pruning for AI agents.

Read the full research →

Try it now

Paste a log dump, set your query and budget, and run the live pipeline.

Token budget 8,000
Raw context 0 chars
Telemetry
Input
—
Output
—
Saved
—
Chunks: —
Latency: —
Lines: —
Critical: —
Pruned output
// Run prune to see optimized context…
// ready

Pricing

Start free, upgrade when logs get serious. No credit card for the CLI.

Free Tier

For developers exploring Roka

$0/month
  • → Local CLI tool (no cloud required)
  • → Up to 50K tokens/month
  • → Basic deduplication & fingerprinting
Get Started View on GitHub

Pro Tier

For developers & small teams serious about speed

$20/month (or $14/month annual)
  • → Web UI + REST API
  • → 500K tokens/month
  • → Semantic re-ranking + critical preservation
  • → One-click agent integration (MCP)
  • → Natural language query understanding
  • → MCP servers for Claude Code, Cursor & Codex — auto-prune on crash
Start 7-Day Free Trial Pay Now

Enterprise

For teams & companies at scale

Custom pricing
  • → Unlimited tokens
  • → Custom integrations (Splunk, DataDog, GitHub)
  • → Slack channel integration
  • → SSO & audit logs
Contact Sales

Free — structural patterns

Deduplication, fingerprinting, and token-budget packing. Handles the repetition problem. Works entirely offline, no account needed.

Pro — understands intent

Semantic re-ranking surfaces what matters to your query. Ask "why did auth break?" — Pro ranks the relevant slice first. Plus MCP servers for real-time crash detection.

Feature Comparison

Feature Free Pro Enterprise
Cost Free $20 Custom
Tokens 50K 500K ∞
API CLI REST Full
Semantic — ✓ ✓
Natural language queries — ✓ ✓
One-click MCP integration — ✓ ✓
Real-time crash-log MCP server — ✓ ✓

FAQ

Three reasons:

1. File size: Claude limits files to ~100MB. Roka handles unlimited size.

2. Cost: A 500K token log file costs ~$2 in Claude API. Roka processes it locally for free, then sends only the 50K tokens that matter. 10x cheaper at scale.

3. Speed: Roka processes in 312ms. Upload + Claude = 10+ seconds.

Plus: Roka runs locally (your logs stay on your machine). Claude needs an upload every time.

Semantic search finds relevant chunks. Roka does that PLUS:

- Critical preservation: Never collapses PANIC, OOM, auth errors, or stack traces. These always make it through.

- Pattern fingerprinting: Treats 1,000 identical "Connection pool warning" messages as one, not spam.

- Dependency awareness: Understands your code's architecture, so it ranks errors in the critical path higher.

Result: Claude gets 70% less data, 100% more useful data.

Free: Local CLI tool, 50K tokens/month, basic deduplication.

Pro: Web UI + API, 500K tokens/month, semantic ranking, critical preservation, priority support. $20/month.

Most developers use Free for occasional debugging. Teams and on-call engineers use Pro.

Yes. The CLI tool (Free tier) works entirely offline. Pro tier requires internet for API calls.

No. Local CLI: logs stay on your machine. Pro/API: we process them in-flight and delete after 24 hours. We don't index, train on, or store your data.

Your logs are yours.

Average: 312ms for 50K token dumps.

Larger files scale linearly. A 500K dump typically takes 3-5 seconds including semantic re-ranking.

Yes. The CLI is model-agnostic — pruned output goes to stdout, so you can pipe it into Claude, GPT, Gemini, Cursor, or anything else.

MCP connect currently wires Claude Code, Cursor, Codex, and Copilot (plus Windsurf / VS Code / Cline). We're building Roka as a context layer, not a single-vendor tool.

Free: 50K tokens/month.

Pro: 500K tokens/month.

Enterprise: Unlimited. Custom SLAs.

Yes. Pipe or call Roka in CI, on-call scripts, or agent workflows — e.g. logs → Roka → your model → Slack. We're early (MVP); start with the CLI / MCP tools and tell us what you need for production hardening.

Local CLI / MCP prune tools: your machine, your data — pruning does not upload logs.

Pro cloud / API: TLS in transit; we don't train on your logs. Formal compliance (SOC 2, SSO, residency) is on the Enterprise roadmap — email us if you need a security questionnaire.

We're early — no fake conversion stats. Free is the local CLI with a 50K token/month ceiling and basic fingerprinting. Upgrade to Pro when you need MCP agent connect, semantic re-ranking, higher limits, or the web/API. Occasional debugging usually stays free; daily CI / on-call use is where Pro pays for itself.

Roka streams the file in chunks so memory usage stays flat regardless of file size. Benchmarks on a 2021 M1 MacBook Pro:

• 50K tokens → ~312ms
• 500K tokens → ~3–5s (with semantic re-ranking)
• 5M tokens → ~25–40s (BM25 only, semantic disabled)

For very large files we recommend using --no-semantic for speed, or splitting by time window first. There is no hard size limit.

Roka's own models, running locally on your machine. Semantic re-ranking uses sentence-transformers (open weights, ~80MB) bundled into the binary — no API calls, no data leaves your machine during pruning.

Your logs are never sent to OpenAI, Anthropic, or any third party as part of the pruning step. Only the pruned output goes to your AI provider — and only when you explicitly pipe it there.

Try Roka now (it's free!!).

Start now
(Kev approves.)