Entroly

Name: Entroly
Author: Jupyterman

Local context selection, compression receipts and work handoffs for coding agents

By Jupyterman (individual) Python Local · stdio Developer tools Knowledge and memory

GitHub npm PyPI Website

42 popularity score ★ 483 ↓ 425/wk

Connect your client

Local (npm)

Add in one click

Add to Cursor Add to VS Code Add to LM Studio Add to Goose

Opens the app, which asks before it adds the server.

Or add it by command or config

FirstTerminal

pip install -U entroly

Claude CodeTerminal

claude mcp add entroly -- npx -y entroly-mcp serve

Claude Desktopclaude_desktop_config.json

{
  "mcpServers": {
    "entroly": {
      "command": "npx",
      "args": [
        "-y",
        "entroly-mcp",
        "serve"
      ]
    }
  }
}

Cursor~/.cursor/mcp.json

{
  "mcpServers": {
    "entroly": {
      "command": "npx",
      "args": [
        "-y",
        "entroly-mcp",
        "serve"
      ]
    }
  }
}

VS Code.vscode/mcp.json

{
  "servers": {
    "entroly": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "entroly-mcp",
        "serve"
      ]
    }
  }
}

Codex~/.codex/config.toml

[mcp_servers.entroly]
command = "npx"
args = ["-y", "entroly-mcp", "serve"]

Gemini CLITerminal

gemini mcp add --scope user entroly npx -- -y entroly-mcp serve

Local (PyPI)

Add in one click

Add to Cursor Add to VS Code Add to LM Studio

Opens the app, which asks before it adds the server.

Or add it by command or config

FirstTerminal

pip install -U entroly

Claude CodeTerminal

claude mcp add entroly -- entroly serve

Claude Desktopclaude_desktop_config.json

{
  "mcpServers": {
    "entroly": {
      "command": "entroly",
      "args": [
        "serve"
      ]
    }
  }
}

Cursor~/.cursor/mcp.json

{
  "mcpServers": {
    "entroly": {
      "command": "entroly",
      "args": [
        "serve"
      ]
    }
  }
}

VS Code.vscode/mcp.json

{
  "servers": {
    "entroly": {
      "type": "stdio",
      "command": "entroly",
      "args": [
        "serve"
      ]
    }
  }
}

Codex~/.codex/config.toml

[mcp_servers.entroly]
command = "entroly"
args = ["serve"]

Gemini CLITerminal

gemini mcp add --scope user entroly entroly -- serve

Settings 9

`ENTROLY_MCP_PROFILE`	Optional: public for the 22-tool surface, full (default) for all tools.
`ENTROLY_MCP_PASSIVE`	Optional: 1 stops background watchers, indexing and tuning at start; tools still work.
`ENTROLY_SOURCE`	Optional: Repository root the server works in; defaults to the working directory.
`ENTROLY_DIR`	Optional: Directory for Entroly's shared local state.
`ENTROLY_MAX_FILES`	Optional: Cap on files indexed; the project's snippets set 200.
`ENTROLY_BUDGET`	Optional: Token budget for context selection.
`ENTROLY_NO_DOCKER`	Optional: 1 keeps it from launching through Docker.
`ENTROLY_MCP_TRANSPORT`	Optional: stdio by default; sse serves on ENTROLY_MCP_PORT (9379).
`ENTROLY_BRAIN_EXECUTE`	Optional: 1 registers brain_execute_script, which runs Python code.

What it does

Entroly is a local Python tool for AI coding agents that picks which parts of a repository go into a model's context within a token budget, writes a receipt of what was kept and what was dropped, and keeps the dropped material on disk so it can be recovered by handle. The MCP server is one of several ways to use it, next to a command-line tool, a Python SDK, an HTTP proxy and host plugins.

Through MCP an agent can read a source file in reduced form, search stored fragments, build a token-bounded bundle for a query, create and inspect context receipts, save and resume checkpoints, and estimate how well a response is grounded in supplied evidence. A set of work_ tools keeps a local record of who claimed a task, hands work from one agent to another (for example Claude Code to Codex) and records code reviews against the observed git state.

The tool list depends on ENTROLY_MCP_PROFILE. Running `entroly serve` directly defaults to the full profile: in server.py at version 1.0.87 that is 86 tools (70 in server.py plus 16 work-graph tools), and 87 when ENTROLY_BRAIN_EXECUTE=1 adds brain_execute_script, which runs a Python script against the workspace. The `public` profile, which the project's own marketplace snippets set, trims this to 22 tools and renames smart_read, get_stats and entroly_retrieve to read_source_file, get_session_stats and retrieve_context.

What it needs

Runtime	PythonorNode.js

Python with pip (pip install -U entroly), or uv for uvx. The npm package entroly-mcp is only a bridge: it forwards to an installed Python entroly, so Node.js and the Python package are both needed for that way. Query-based selection needs the native engine entroly-core; if it is missing, install it with pip install -U entroly-core. No account or sign-in is needed for the MCP tools.

Limits

MCP tools are advisory: the model may skip calling them, and only the proxy or a verified host hook applies selection to every request. Receipts show what was selected; they do not prove an answer is correct or that cost went down. verify_response estimates grounding against evidence you pass in and is not an external fact-check. Recovery fails if the local recovery store or source bytes are deleted. The work handoff and review records need shared local state on one machine; multi-machine use is not offered. Without the native engine, relevance ranking is off and reduction figures are marked unearned.

Who it suits

Suits developers running coding agents on large repositories who want an inspectable record of what context the agent saw, local memory across sessions, or a handoff trail between two agents on the same checkout. Everything runs on the user's machine. Set ENTROLY_MCP_PROFILE=public unless you want all 86 tools in the agent's list. If you control your app's API base URL, the project's own proxy mode applies selection to every request, which the MCP tools cannot. Those who only want a file reader or a notes store will find most of its surface unused.

Tools 53 of 86

recall_relevant: Searches stored fragments for ones relevant to a task query
read_source_file: Reads a workspace file, reducing less relevant blocks (public-profile name of smart_read)
locate_evidence: Pins exact spans inside text the caller passes in
remember_fragment: Stores caller-supplied text in the local fragment index
optimize_context: Returns a token-bounded bundle from the indexed corpus for a query
create_context_receipt: Selects context and records what was kept and omitted in a receipt
recover_receipt_omission: Recovers a chunk a receipt left out
retrieve_context: Fetches original content by its recovery handle (public-profile name of entroly_retrieve)
checkpoint_state: Saves the session state as a checkpoint
resume_state: Restores a saved checkpoint
verify_response: Estimates how well a response is grounded in supplied evidence
record_test_result: Records the outcome of a test that already ran
get_session_stats: Reports local counters and savings estimates (public-profile name of get_stats)
work_capabilities: Reports the repository root and what the work graph can do
work_claim: Claims a task for the calling agent
work_state: Shows current work state and the workstream id
work_handoff: Hands a workstream to another agent
work_pending_handoffs: Lists handoffs waiting for this agent
work_resume: Rebuilds unfinished work from repository evidence
work_acknowledge_recovery: Acknowledges recovered state before further claims
work_record_review: Records a review statement bound to git state and file digests
work_reviews: Lists reviews and whether the reviewed source is still current
work_modifications: Lists changes the workspace watcher saw between observations
work_session_status: Reports the takeover done when the server started
explain_context: Explains why fragments were selected
render_context_receipt: Renders a receipt as a readable report
explain_receipt_omission: Explains why a receipt left a chunk out
prefetch_related: Suggests files likely needed next from co-access patterns
repo_file_map: Returns Entroly's own file map across its Python, Rust and WASM repos
analyze_codebase_health: Reports health findings on the ingested codebase
scan_for_vulnerabilities: Runs static security analysis on code content
security_report: Summarises security findings across ingested fragments
ingest_diff: Adds a diff to the context index
ingest_diagram: Adds a diagram to the context index
ingest_voice: Turns a meeting transcript into a stored fragment of decisions and actions
shared_memory_write: Writes an entry to memory shared between agents
shared_memory_search: Searches the shared agent memory
vault_query: Looks up beliefs in the local knowledge vault
vault_search: Searches the local knowledge vault
vault_write_belief: Writes a belief to the vault
vault_write_action: Writes a task output or report to the vault
compile_docs: Turns markdown docs into vault belief entries
verify_beliefs: Runs a verification pass over vault beliefs
blast_radius: Shows which beliefs a file change affects
eicv_verify_claim: Checks one claim against evidence
start_workspace_listener: Starts a polling watcher on the workspace, every 120 s by default
sync_workspace_changes: Reconciles workspace changes into the local index
record_outcome: Records whether selected fragments led to a good result
export_training_data: Exports vault beliefs as JSONL
create_skill: Creates a skill from a capability gap
manage_skills: Manages the skill lifecycle
entroly_dashboard: Shows live session value figures
brain_execute_script: Runs a Python script over the workspace; only with ENTROLY_BRAIN_EXECUTE=1

Popularity

42 popularity score, on our list (the bar is 36)

★ 483 ↓ 425/wk

GitHub stars, whole repository	483	21 points
npm downloads, last week	425	21 points
PyPI downloads, last month	1,455

It lives in the folder entroly/npm of juyterman1000/entroly, which holds more than this server. Its stars are the whole repository's, so in the score they never count for more than its own downloads.

Measured 2026-11-07. How the score works.

Where it is published

Code	juyterman1000/entroly/entroly/npm ★ 483, the whole repository
npm	entroly-mcp 1.0.88, 2026-11-01, the one the command runs
PyPI	entroly

What it can reach

Runs	On your machine
Reaches	Files on your machine, Your code
Changes things	Yes: it can write, send, create or delete
Sign-in	None
Licence	Apache-2.0 (npm)
Last code change	2026-11-01

Runs locally as a Python process over stdio (SSE on port 9379 when ENTROLY_MCP_TRANSPORT=sse). Tools read files under the project root (ENTROLY_SOURCE, else the working directory) and write local indexes, receipts, recovery data, vault entries and work records; learn_from_failures can optionally apply corrections to agent config files. brain_execute_script, which runs Python code, is registered only when ENTROLY_BRAIN_EXECUTE=1. The MCP tools need no credentials. Per the README, product telemetry is off by default and runtime package repair is opt-in (ENTROLY_ENABLE_SELF_HEAL=1 lets it download from PyPI); an optional WITNESS NLI check can send evidence and claims to OpenAI.

Over time

GitHub stars, whole repository 483 +6 (+1 %)

483476

13 Oct 20267 Nov 2026

npm downloads a week 425 +331 (+352 %)

1.4k2

16 Mar 20267 Nov 2026

Before the site measured it, read from npm's daily download counts.

Popularity score 42 −10 (−20 %)

5341

13 Oct 20267 Nov 2026

What is rising across the directory

Sources

Page checked 2026-10-15.

Badge for your README

Shows this server's rank in its category, and stars for a server that runs on your machine. It updates every hour.

MarkdownREADME.md

[![Entroly on EveryMCPServer](https://everymcpserver.com/badge/entroly.svg)](https://everymcpserver.com/servers/entroly)

Connect your client

Add in one click

Or add it by command or config

Add in one click

Or add it by command or config

Settings 9

What it does

What it needs

Limits

Who it suits

Tools 53 of 86

Similar servers

OpenLore

Engram

basemind

SuperSkill

Claude-Mem

Memtrace