Atlas / MCP servers / yogthos / Matryoshka

MatryoshkaBLOCK

Name: Matryoshka
Author: yogthos

mcp/yogthos/matryoshka

MCP server by yogthos · ai assistant · document analysis · llm · Audited 2026-10-07

⚑ Report / re-scan Source ↗

MCP server for token-efficient large document analysis via the use of REPL state

Verdict

BLOCK

Grade

Trust score

59 /100

Exposed tools

78 71r · 4w · 3d

Transport

stdio

License

Apache-2.0

Stars

149

Overview

From the repository's own README, as read at the audited commit. Badges and raw HTML are left out.

[](https://github.com/yogthos/Matryoshka/actions/workflows/test.yml) [](https://safeskill.dev/scan/yogthos-matryoshka)

Process documents 100x larger than your LLM's context window—without vector databases or chunking heuristics.

The Problem

LLMs have fixed context windows. Traditional solutions (RAG, chunking) lose information or miss connections across chunks. RLM takes a different approach: the model reasons about your query and outputs symbolic commands that a logic engine executes against the document.

Based on the Recursive Language Models paper.

How It Works

Unlike traditional approaches where an LLM writes arbitrary code, RLM uses [Nucleus](https://github.com/michaelwhitford/nucleus)—a constrained symbolic language based on S-expressions. The LLM outputs Nucleus commands, which are parsed, type-checked, and executed by Lattice, our logic engine.

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│   User Query    │────▶│   LLM Reasons   │────▶│ Nucleus Command │
│ "total sales?"  │     │  about intent   │     │  (sum RESULTS)  │
└─────────────────┘     └─────────────────┘     └────────┬────────┘
│
┌─────────────────┐     ┌─────────────────┐     ┌────────▼────────┐
│  Final Answer   │◀────│ Lattice Engine  │◀────│     Parser      │
│   13,000,000    │     │    Executes     │     │    Validates    │
└─────────────────┘     └─────────────────┘     └─────────────────┘

Why this works better than code generation:

Reduced entropy - Nucleus has a rigid grammar with fewer valid outputs than JavaScript
Fail-fast validation - Parser rejects malformed commands before execution
Safe execution - Lattice only executes k

Read from source at commit 3a2549633d52OBSERVED · 2026-10-07

Connect

Built from this server's own package name, version and transport as found in its source — not copied from anyone's documentation, so it cannot drift against a page we do not control. Replace the environment placeholders with a token scoped to the least it needs.

claude-code

claude mcp add matryoshka-rlm --env API_KEY=${API_KEY} --env MISSING_KEY=${MISSING_KEY} --env TEST_API_KEY=${TEST_API_KEY} --env TEST_EMBEDDED_TOKEN=${TEST_EMBEDDED_TOKEN} -- npx -y [email protected]

claude-desktop

{
  "mcpServers": {
    "matryoshka-rlm": {
      "command": "npx",
      "args": [
        "-y",
        "[email protected]"
      ],
      "env": {
        "API_KEY": "${API_KEY}",
        "MISSING_KEY": "${MISSING_KEY}",
        "TEST_API_KEY": "${TEST_API_KEY}",
        "TEST_EMBEDDED_TOKEN": "${TEST_EMBEDDED_TOKEN}"
      }
    }
  }
}

Exposed tools (78)

71 read · 4 write · 3 destructive. Blast radius: 3 tools can delete or overwrite — an agent that can be talked into calling a tool can be talked into calling this one.

Tool	Risk	Description
`analyze_document`	read	Analyze a document using the Recursive Language Model (RLM).
`auto_synthesized`	read	Synthesized from ${inputs.length} examples
`bad`	read
`batch_llm_query`	write	Execute multiple LLM queries in parallel. Much faster than sequential llm_query calls when you need to process multiple chunks or sections. All prompts are sent simultaneously.
`bracket_content`	read	Extract content from brackets
`bracket_extract`	read	Extract content from square brackets
`child1`	read
`child2`	read
`context.match`	read	Search context with a regular expression. Returns all matches.
`context.slice`	read	Get a portion of the context by character indices. Use sparingly - prefer fuzzy_search to find relevant sections first.
`count_tokens`	read	Estimate the token count of text. Useful for checking if a section will fit in an LLM call. Uses word-based heuristics (most words = 1 token).
`currency`	read	Currency pattern
`currencyExtractor`	read	Extracts currency as number
`currency_decimal`	read	Extract decimal from dollar currency
`currency_extractor`	read
`currency_integer`	read	Extract integer from dollar currency
`date`	read	Date pattern
`derived`	read
`digits`	read
`empty`	read
`extractor1`	read
`fuzzy_search`	read	Find approximate keyword matches using fuzzy string matching. Returns matching lines with line numbers and match scores (lower score = better match). NOTE: Takes a single search term, NOT regex. For regex patterns use grep() instead.
`good`	read
`grep`	read	Fast regex search with line numbers. More efficient than context.match for finding specific patterns. Returns matches with line numbers and character indices.
`high`	read
`high-usage`	read	high usage component
`imported`	read
`integer_commas`	read	Parse integer with comma separators
`integer_plain`	read	Parse plain integer
`key_equals_value_extract`	read	Extract value from key=value pattern
`key_value_extract_key`	read	Extract key from key: value pattern
`key_value_extract_value`	read	Extract value from key: value pattern
`lattice_bindings`	read	Show current handle bindings. Returns all active handles with their stubs: $grep_error: Array(500) [preview of first item...] $filter: Array(50) [preview...] RESULTS: -> $filter Use this to see what data you have available before deciding what to expand.
`lattice_close`	read	Close the current session and free memory.
`lattice_expand`	read	Get full data from a handle when you need to inspect actual results. USE THIS WHEN: - You need to see actual content to make decisions - You want to verify what
`lattice_help`	read	Get complete Nucleus command reference documentation.
`lattice_llm_respond`	read	Resolve a pending (llm_query ...) suspension with a single string response. When lattice_query hits (llm_query ...) and the client doesn
`lattice_load`	read	Load a document for analysis. Call this first before querying.
`lattice_memo_delete`	destructive	Delete a memo that is no longer needed to free memory. Use this when context becomes stale or irrelevant (e.g., after finishing work on a module). Check lattice_bindings to see current memos and their handles.
`lattice_query`	write	Execute a Nucleus query on the loaded document. RETURNS HANDLE STUBS (not full data): - Array results return a handle like
`lattice_reset`	destructive	Clear all handles and bindings but keep the document loaded. Use this to start fresh analysis.
`lattice_stats`	read	Get statistics about the currently loaded document.
`lattice_status`	read	Get current session status including document info, active handles, and timeout.
`llm_query`	read	Query a sub-LLM to process a chunk of text. Expensive operation - batch related information when possible to minimize calls. Use format:
`locate_line`	read	Extract lines by line number (1-based). More precise than slice() for line-based navigation. Supports negative indices to count from end.
`log_level_extract`	read	Extract log level from log line
`lonely`	read
`low`	read
`minikanren_synthesized`	read	Synthesized via miniKanren relational search
`new-component`	read
`nucleus_commands`	read	Get reference documentation for available Nucleus commands.
`nucleus_execute`	write	Execute Nucleus commands directly on a document without LLM orchestration.
`number`	read	Number pattern
`original`	read	test description
`paren_content`	read	Extract content from parentheses
`parent`	read
`percentage_to_decimal`	read	Convert percentage to decimal
`prefix_suffix_strip`	destructive	Remove prefix ${JSON.stringify(inputPrefix.slice(0, 50))} and suffix ${JSON.stringify(inputSuffix.slice(0, 50))}
`regex`	read
`regex1`	read
`regex2`	read
`removable`	read
`split_comma`	read	Split by comma
`split_pipe`	read	Split by pipe
`structured_currency_extract`	read	Extract currency value from structured text
`structured_number_extract`	read	Extract number from structured text
`template_synthesized`	read	Template synthesized from ${inputs.length} examples
`test`	read
`test1`	read
`test2`	read
`test_high`	read
`test_low`	read
`test_regex`	read	test
`test_transform`	read	test
`text_stats`	read	Get document metadata WITHOUT reading tokens: length, line count, and 5-line samples from start/middle/end. Use this first to understand document structure.
`toNumber`	read
`trigger`	write
`zero-usage`	read	never used component

Trust audit

BLOCKgrade F · trust 59/100 Do not install this without reading the findings. The audit found something that could harm you or your machine.

Layer	What it checks	Result
L0	Provenance & inventory	PASS
L1	Static analysis of the code	FAIL
L2	Instruction surface (what it tells the agent)	PASS
L3	Class-specific surface	WARN
L4	Behavioural (sandbox)	SKIPPED