Skip to main content
Glama
Lotus Wisdom MCP Server

Lotus Wisdom MCP Server

README.md
# 🪷 Lotus Wisdom MCP Server

<p align="center">
  <img src="assets/lotus-flower.png" alt="Lotus Flower" width="400"/>
</p>

An MCP server implementation that provides a tool for problem-solving using the Lotus Sutra's wisdom framework, combining analytical thinking with intuitive wisdom.

Available at: https://lotus-wisdom-mcp.linxule.workers.dev/mcp

## Features

* Multi-faceted problem-solving approach inspired by the Lotus Sutra
* Step-by-step thought process with different thinking techniques
* Meditation pauses to allow insights to emerge naturally
* **Interactive visualization** via MCP ext-apps (Claude Desktop, Cursor, ChatGPT) — a pixel halo that lights one segment per step, in night and day variants that follow the host theme; keyboard-accessible and respects reduced motion
* **MCP Prompts** (`contemplate`, `deep-inquiry`) for one-step guided contemplative sessions
* **Structured tool output** (`structuredContent` + `outputSchema`) alongside the text response
* Tracks both tag journey and wisdom domain movements
* Available as a local stdio package (`npx`) or a hosted remote Connector
* Final integration of insights into a clear response

## Background

This MCP server was developed from the [Lotus OS prompt](https://github.com/linxule/prompts/blob/main/cognitive-techniques/lotus_os.md), which was designed to implement a cognitive framework based on the Lotus Sutra. The MCP server format makes this framework more accessible and easier to use with Claude and other AI assistants.

The MCP server exposes the framework through tools and prompts. How well a model follows that framework depends on the model and host.

## Implementation Details

The server implements a structured thinking process using wisdom domains inspired by the Lotus Sutra:

### Wisdom Domains and Tags

The server organizes thoughts using wisdom domains (all valid values for the `tag` input parameter):

* **Entry** (🚪): `begin`
  - Begin your journey here - receives the full framework before contemplation starts

* **Skillful Means** (🔆): `upaya`, `expedient`, `direct`, `gradual`, `sudden`
  - Different approaches to truth - sometimes direct pointing, sometimes gradual unfolding

* **Non-Dual Recognition** (☯️): `recognize`, `transform`, `integrate`, `transcend`, `embody`
  - Aspects of awakening to what's already present - recognition IS transformation

* **Meta-Cognitive** (🧠): `examine`, `reflect`, `verify`, `refine`, `complete`
  - The mind watching its own understanding unfold

* **Process Flow** (🌊): `open`, `engage`, `express`
  - A natural arc that can contain any of the above approaches

* **Meditation** (🧘): `meditate`
  - Pausing to let insights emerge from stillness

### Thought Visualization

In clients that support MCP ext-apps, each step renders inline as an interactive halo (see [Interactive Visualization](#interactive-visualization-ext-apps) below). For every client, each step also returns:

* Journey tracking showing both the tag path and the wisdom-domain movements
* Domain-specific labels and the current contemplation text
* Structured output (`structuredContent` + `outputSchema`) for programmatic consumers

Note: The local stdio server can emit per-step trace lines to its console (stderr) when run with `LOTUS_DEBUG=true`, helping developers follow the thinking process.

### Process Flow

1. The user submits a problem to solve
2. The model begins with `tag='begin'` to receive the full framework
3. The model continues with contemplation tags (open, examine, integrate, etc.)
4. Each thought builds on previous ones and may revise understanding
5. The tool tracks both the tag journey and wisdom domain movements
6. Meditation pauses can be included for clarity
7. When status='WISDOM_READY' is returned, the tool's work is complete
8. The model then expresses the final wisdom naturally in its own voice

## Available Tools

### lotuswisdom

A tool for problem-solving using the Lotus Sutra's wisdom framework, with various approaches to understanding.

**Begin your journey with `tag='begin'`** - this returns the full framework (philosophy, domains, guidance) to ground your contemplation. Then continue with the other tags.

**Inputs:**

* `tag` (string, required): The current processing technique (must be one of the tags listed above)
* `content` (non-empty string, required): The content of the current processing step, including `begin`
* `stepNumber` (integer, optional, default `1`): Current number in sequence
* `totalSteps` (integer, optional, default `5`): Estimated total steps needed
* `nextStepNeeded` (boolean, optional, default `true`): Whether another step is needed
* `isMeditation` (boolean, optional): Whether this step is a meditative pause
* `meditationDuration` (integer, optional): Duration for meditation in seconds (1-10)
* `previousJourney` (string, optional): The `journey` string from a previous response, e.g. `"begin → open → examine"`. Lets the AI carry journey continuity forward in stateless clients (such as the remote Worker), where the server keeps no session state.

**Returns:** a JSON text block and `structuredContent` validated against the tool's
`outputSchema`. Every successful response includes `journey` for continuity,
including `begin` and completion. Completion also retains `finalJourney` for
compatibility. For `begin`, the full framework is in the text block; structured
output contains its status, welcome, contemplation, journey, domain journey,
and step counts. Other result variants retain their fields in both representations.

A meditation step with `nextStepNeeded: false` completes the inquiry with
`WISDOM_READY`; ongoing meditation steps return `MEDITATION_COMPLETE`.

Response statuses include:

- Processing status with current step information, wisdom domain, and journey tracking
- `FRAMEWORK_RECEIVED` status on a `begin` step
- `MEDITATION_COMPLETE` status for meditation steps
- `WISDOM_READY` status when the contemplative process is complete

The tool declares `readOnlyHint`, `idempotentHint`, `destructiveHint: false`, and `openWorldHint: false`. These are host hints, not a guarantee of zero side effects: local stdio calls update the in-memory journey, and the hosted worker records usage analytics. The tools do not modify user files or external business data.

### lotuswisdom_summary

Get a summary of the current contemplative journey.

**Inputs:**

* `previousJourney` (string, optional): The `journey` string from a previous response, used to reconstruct the summary in stateless clients.

**Returns:**
- Journey length
- Domain journey showing movement between wisdom domains
- Summary of all steps with their tags, domains, and brief content

## MCP Prompts

The server registers two prompts that scaffold a guided contemplative session (surfaced as slash commands or prompt pickers in clients that support MCP Prompts):

* **`contemplate`** — argument `question`: opens a single-question contemplation, instructing the model to start with `tag='begin'`, iterate, and speak the wisdom only once `status='WISDOM_READY'`.
* **`deep-inquiry`** — argument `topic`: begins a longer inquiry that moves deliberately across the wisdom domains (process → meta-cognitive → non-dual → meditation).

## Usage

The Lotus Wisdom tool is designed for:

* Breaking down complex problems requiring multi-faceted understanding
* Questions that benefit from both direct and gradual approaches
* Problems where apparent contradictions need integration
* Situations requiring both analytical and intuitive understanding
* Tasks that benefit from meditative pauses to allow insight
* Questions containing their own inherent wisdom

## Example Usage

Here's how a conversation with Claude might flow when using the Lotus Wisdom MCP server:

**User**: "Help me understand the relationship between freedom and responsibility."

**Claude** would begin the journey with `tag='begin'` to receive the framework, then continue:

1. First, enter the contemplative space:
```json
{
  "tag": "begin",
  "content": "Entering contemplation on freedom and responsibility.",
  "stepNumber": 1,
  "totalSteps": 6,
  "nextStepNeeded": true
}
```
→ Returns `FRAMEWORK_RECEIVED` with full framework

2. Then, establish an opening thought:
```json
{
  "tag": "open",
  "content": "The question explores the relationship between freedom and responsibility, which contain an apparent tension but also deep connection.",
  "stepNumber": 2,
  "totalSteps": 6,
  "nextStepNeeded": true
}
```

3. Engage with different perspectives:
```json
{
  "tag": "direct",
  "content": "Freedom and responsibility are two sides of the same coin. True freedom isn't absence of constraints but the capacity to choose our response within constraints.",
  "stepNumber": 3,
  "totalSteps": 6,
  "nextStepNeeded": true
}
```

4. Perhaps take a meditation pause:
```json
{
  "tag": "meditate",
  "content": "Contemplating how freedom without responsibility becomes chaos, and responsibility without freedom becomes oppression.",
  "stepNumber": 4,
  "totalSteps": 6,
  "nextStepNeeded": true,
  "isMeditation": true
}
```

5. Integrate the understanding:
```json
{
  "tag": "integrate",
  "content": "Freedom and responsibility mutually enable each other. Our freedom to choose gives rise to our responsibility for what we choose, and our willingness to take responsibility expands our freedom.",
  "stepNumber": 5,
  "totalSteps": 6,
  "nextStepNeeded": true
}
```

6. Express the final understanding:
```json
{
  "tag": "express",
  "content": "The paradox resolves when we see that authentic freedom includes responsibility as its natural expression.",
  "stepNumber": 6,
  "totalSteps": 6,
  "nextStepNeeded": false
}
```

When the tool returns `status: 'WISDOM_READY'`, Claude then speaks the final wisdom naturally, integrating all the insights from the contemplative journey.

## Installation

Install via [Smithery](https://smithery.ai/server/@linxule/lotus-wisdom-mcp) for one-click setup, or follow the manual instructions below.

Requires [Node.js](https://nodejs.org/) 20+. The server runs locally via `npx`.

### CLI Install (one-liner)

```bash
# Claude Code
claude mcp add lotus-wisdom -- npx -y lotus-wisdom-mcp

# Codex CLI (OpenAI)
codex mcp add lotus-wisdom -- npx -y lotus-wisdom-mcp

# Gemini CLI (Google)
gemini mcp add lotus-wisdom npx -y lotus-wisdom-mcp
```

### Claude Desktop

Add to your `claude_desktop_config.json`:

| OS | Config path |
|----|-------------|
| macOS | `~/Library/Application Support/Claude/claude_desktop_config.json` |
| Windows | `%APPDATA%\Claude\claude_desktop_config.json` |
| Linux | `~/.config/Claude/claude_desktop_config.json` |

```json
{
  "mcpServers": {
    "lotus-wisdom": {
      "command": "npx",
      "args": ["-y", "lotus-wisdom-mcp"]
    }
  }
}
```

### VS Code

Add to `.vscode/mcp.json` (workspace) or open Command Palette > `MCP: Open User Configuration` (global):

```json
{
  "servers": {
    "lotus-wisdom": {
      "command": "npx",
      "args": ["-y", "lotus-wisdom-mcp"]
    }
  }
}
```

> **Note**: VS Code uses `"servers"` as the top-level key, not `"mcpServers"`. Other VS Code forks (Trae, Void, PearAI, etc.) typically use this same format.

### Cursor

Add to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (project):

```json
{
  "mcpServers": {
    "lotus-wisdom": {
      "command": "npx",
      "args": ["-y", "lotus-wisdom-mcp"]
    }
  }
}
```

### Windsurf

Add to `~/.codeium/windsurf/mcp_config.json` (Windows: `%USERPROFILE%\.codeium\windsurf\mcp_config.json`):

```json
{
  "mcpServers": {
    "lotus-wisdom": {
      "command": "npx",
      "args": ["-y", "lotus-wisdom-mcp"]
    }
  }
}
```

### Cline

Open MCP Servers icon in Cline panel > Configure > Advanced MCP Settings, then add:

```json
{
  "mcpServers": {
    "lotus-wisdom": {
      "command": "npx",
      "args": ["-y", "lotus-wisdom-mcp"]
    }
  }
}
```

### Cherry Studio

In Settings > MCP Servers > Add Server, set Type to `STDIO`, Command to `npx`, Args to `-y lotus-wisdom-mcp`. Or paste in JSON/Code mode:

```json
{
  "lotus-wisdom": {
    "name": "Lotus Wisdom",
    "command": "npx",
    "args": ["-y", "lotus-wisdom-mcp"],
    "isActive": true
  }
}
```

### Witsy

In Settings > MCP Servers, add a new server with Type: `stdio`, Command: `npx`, Args: `-y lotus-wisdom-mcp`.

### Codex CLI (TOML config)

Alternatively, edit `~/.codex/config.toml` directly:

```toml
[mcp_servers.lotus-wisdom]
command = "npx"
args = ["-y", "lotus-wisdom-mcp"]
```

### Gemini CLI (JSON config)

Alternatively, edit `~/.gemini/settings.json` directly:

```json
{
  "mcpServers": {
    "lotus-wisdom": {
      "command": "npx",
      "args": ["-y", "lotus-wisdom-mcp"]
    }
  }
}
```

### Windows

On Windows, `npx` requires a shell wrapper. Replace `"command": "npx"` with:

```json
{
  "command": "cmd",
  "args": ["/c", "npx", "-y", "lotus-wisdom-mcp"]
}
```

For CLI tools on Windows:

```bash
claude mcp add lotus-wisdom -- cmd /c npx -y lotus-wisdom-mcp
codex mcp add lotus-wisdom -- cmd /c npx -y lotus-wisdom-mcp
```

### ChatGPT

ChatGPT only supports remote MCP servers over HTTPS. Use [Smithery](https://smithery.ai/server/@linxule/lotus-wisdom-mcp) or connect directly to the hosted instance below via ChatGPT Settings > Connectors.

### Remote (hosted)

A public instance is available at `https://lotus-wisdom-mcp.linxule.workers.dev/mcp`. No API key needed.

For clients supporting Streamable HTTP, connect directly to the URL. For stdio-only clients, use `mcp-remote`:

```json
{
  "mcpServers": {
    "lotus-wisdom": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://lotus-wisdom-mcp.linxule.workers.dev/mcp"]
    }
  }
}
```

To self-host your own instance, see [`worker/README.md`](worker/README.md).

### Building from source

Use Bun 1.4.2 and Node.js 24 to match CI.

```bash
bun install --frozen-lockfile
bun run typecheck
bun run test
bun run build
bun run test:package
bun run start
```

The build installs the app's locked dependencies and rebuilds the tracked
`dist/bundle.js` and `dist/journey.html` artifacts. Check the app with
`cd app && bunx tsc --noEmit && bun run test`. The suite covers the single-file
build (the local Vite plugin inlines JavaScript and CSS into one HTML resource;
tests cover dynamic imports and HTML escaping) and the journey itself:
continuity across frames, meditation, reset between inquiries, exploration of
the completed panel only, and every tag's character rendering from embedded
outlines. See [worker validation](worker/README.md#local-dev) for the worker
typecheck, dry-run build, and local HTTP regression.

To see a journey the way a chat shows it, one frame per call, run
`cd app && bunx vite build` and open `app/preview.html`. The halo's characters
are generated into `app/src/glyphs.ts`; `app/scripts/glyphs.py` regenerates
them from a Noto Serif TC subset and documents how to fetch it.

`bun run test:package` packs the built files, installs the tarball in a temporary
consumer directory, and starts npm's executable link. It checks the MCP version,
tool discovery, a complete inquiry ending in meditation, a fresh inquiry reset,
and the packaged journey HTML. CI runs this check
after building and before publishing, so a broken launcher or missing package
asset blocks the release. It requires npm registry access to install production
dependencies and removes its temporary files on completion.

Dependabot uses the `bun` ecosystem for the root, app, and worker packages so
updates include their `bun.lock` files. CI verifies all three packages on pull
requests. Merging a PR updates source only: a version tag publishes to npm and
the MCP Registry, and the Cloudflare Worker requires a separate deployment.

If npm publishes successfully but MCP Registry registration fails, retry only
registration for the existing tag:

```bash
gh workflow run publish-mcp.yml --ref main -f registry_tag=vX.Y.Z
```

Replace `vX.Y.Z` with the existing published version's tag. This revalidates the
tagged source and waits for npm availability before
registration. It does not republish npm or move the release tag.

Enable debug mode:

```bash
LOTUS_DEBUG=true bun run start
```

## Interactive Visualization (ext-apps)

In MCP clients that support ext-apps (Claude Desktop, Cursor, ChatGPT), each step renders inline as a small panel: a ring of pixels modeled on the LED halos (光背) wired behind temple statues, the step's character at its center, and the contemplation beside it. Each tool call gets its own panel, so a journey reads down the conversation one frame at a time.

* **The ring**: one segment per step, shaded with the ASCII ramp: a ▒ track for steps still estimated to come, ▓ for earlier steps, solid █ for the current one, which dithers in as it arrives. The ring re-divides as `totalSteps` changes and closes exactly when the journey completes.
* **Color is attention**: only the current step is in color; the rest is ink. The colors are the six of the Buddha's aura from the Buddhist flag: Entry white, Process red, Skillful Means yellow, Non-Dual orange, Meta-Cognitive blue, and Meditation the flag's sixth band, a pixel mosaic of all five. When the circle closes it turns white, every color at once (ink in daylight).
* **A character for each tag**: every character comes from Kumārajīva's Lotus Sutra or from Tiantai's reading of it, in traditional forms. open, express, recognize and embody spell 開示悟入, the four aims of the Buddha's appearance in chapter 2, the chapter on skillful means, which also gives 巧 (upaya: 巧說諸法, "skillfully expounds the teachings") and 直 (direct: 正直捨方便, "directly setting means aside"). 照 (reflect) is the light across eighteen thousand worlds (ch. 1), 出 (transcend) the children leaving the burning house (ch. 3), 證 (verify) Many Treasures bearing witness (ch. 11), 淨 (refine) the purified senses (ch. 19). examine and meditate make Tiantai's 止觀. Hover a character for its pinyin and source. Characters are drawn from embedded Noto Serif TC outlines (SIL OFL 1.1), so they look the same with or without CJK fonts.
* **Meditation**: the meditation segment breathes by pixel density three times, then rests.
* **Completion**: the circle closes and turns white, segment by segment. Nothing is added underneath.
* **Look back**: only the completed panel is interactive. Hover or focus a segment to see that step in its color with its character and tag; click or press Enter to pin it; arrow keys walk the ring. Panels for steps still in progress are for reading and do not respond to the pointer. Steps carried over from earlier frames show their place; their words stay in those frames.
* **Quiet by design**: nothing loops, nothing glows, and with `prefers-reduced-motion` every state appears without animation. The design came out of a Lotus Wisdom journey on its own UI; after `cd app && bunx vite build`, open `app/preview.html` to replay that journey as a chat shows it, one frame per call.

Clients without ext-apps support are unaffected — they receive the same JSON tool responses as before.

## How It Works

The Lotus Wisdom framework recognizes that wisdom often emerges not through linear thinking but through a dance between different modes of understanding. The tool facilitates this by:

1. **Tracking Wisdom Domains**: As you move through different tags, the tool tracks which wisdom domains you're engaging, helping you see the shape of your inquiry.

2. **Journey Consciousness**: The tool maintains awareness of your complete journey, showing both the sequence of tags used and the movement between wisdom domains.

3. **Non-Linear Progress**: While steps are numbered, the process isn't strictly linear. You can revisit, revise, and branch as understanding deepens.

4. **Integration Points**: Tags like `integrate`, `transcend`, and `embody` help weave insights together rather than keeping them separate.

5. **Natural Expression**: The tool handles the contemplative process, but the final wisdom is always expressed naturally by the AI, not as formatted output.

### Token Optimization Design

MCP tool descriptions stay in the AI's context window constantly when the server is connected. To minimize this overhead while preserving the full teaching content:

- **Constant context (~150 tokens)**: The `lotuswisdom` tool description is kept minimal—just enough for the AI to know when and how to use it
- **On-demand learning (~1,200 tokens)**: The complete framework is delivered when calling with `tag='begin'`, including:
  - Philosophy and domain spirits
  - Parameter explanations (tag, content, stepNumber, etc.)
  - Response format details (wisdomDomain, journey, domainJourney)
  - Meditation handling (MEDITATION_COMPLETE status)
  - When to use guidance
- **Learn first, practice second**: The `begin` tag ensures models receive complete understanding before contemplating

This approach reduces constant context overhead by ~85% when the tool is idle. When actually used, the full framework is delivered on first step—nothing is lost.

## License

This MCP server is licensed under the MIT License. For more details, please see the LICENSE file in the project repository.

## Contributing

Contributions are welcome! Please feel free to submit issues or pull requests on the [GitHub repository](https://github.com/linxule/lotus-wisdom-mcp).

## Version

Current version: 0.10.0

### What's New in 0.10.0

- Moved the npm stdio server from the v1 `@modelcontextprotocol/sdk` to the
  v2 `@modelcontextprotocol/server` package (2.4.0). Node.js 20 or later is now
  required.
- Moved the Cloudflare Worker to MCP SDK v2 and removed the v1 SDK and the
  Cloudflare Agents SDK from it. It still answers every request with JSON,
  which Claude Desktop Connectors need to render the journey UI, and keeps the
  same CORS headers. The Worker's upload is about 62% smaller.
- Wire changes from SDK v2: tool schemas declare JSON Schema draft 2020-12,
  error messages no longer start with `MCP error <code>:`, and calling an
  unknown tool returns a JSON-RPC `-32602` error instead of an `isError`
  result.

### What's New in 0.9.1

- Updated the MCP SDK, MCP Apps, Cloudflare Agents, and Worker tooling from
  the grouped Dependabot updates.
- Refreshed transitive `@hono/node-server` and `qs` dependencies to patched
  versions, clearing the dependency audit findings in the server and worker.
- Retained the SDK v1 compatibility handler and aligned the worker's MCP
  dependencies with Cloudflare Agents' required peer versions.
- Removed the temporary Undici override now that Worker tooling requires the
  patched version directly.

### What's New in 0.9.0

- Redesigned the journey visualization as a pixel halo: one segment per step,
  a traditional character at its center, and the contemplation beside it.
  Earlier steps appear in ink, future steps as a dim track, and the current
  step in its domain color. The completed circle turns white in the night theme.
- Added embedded Noto Serif TC glyph outlines, with pinyin and source notes on
  hover, so the characters render without installed CJK fonts or font requests.
- Gave each event a finite animation and made only the completed panel
  explorable by hover, focus, pin, and keyboard navigation.
- Kept completed panels at a steady height while looking back, with internal
  scrolling for longer earlier text, and fixed a rapid-hover content fade race.
- Added a daylight palette that follows the host theme, reduced-motion styles,
  DOM regressions, and a development preview showing one frame per tool call.
- Includes the journey reliability and dependency security fixes below; 0.8.6
  was prepared but not published separately.

### Reliability fixes prepared for 0.8.6 (included in 0.9.0)

- Preserved the opening step in stateless journeys by returning continuity
  metadata from `begin`, including in structured output.
- Fixed completion on meditation steps and added `journey` to completion
  responses while retaining `finalJourney`.
- Reset the visualization between inquiries in reused iframes, including
  pending animations, collapsed steps, pins, and completion effects.
- Added response-driven journey regressions for the installed CLI and worker,
  plus DOM tests for consecutive inquiries and animation races.
- Updated dependencies and patched vulnerable transitive packages. The worker
  temporarily overrides Undici until Wrangler's Miniflare dependency is patched.

### What's New in 0.8.1

- Updated dependencies and GitHub Actions, regenerated Bun lockfiles, and added
  app and worker validation to CI.
- Updated vulnerable transitive dependencies across all three packages and added
  dependency audits to CI. All three Bun audits passed during release validation
  on September 14, 2026.
- Migrated the visualization to ext-apps 2 with its MCP client v2 and Zod 4
  dependencies. The server transports remain on MCP SDK v1; the worker uses
  the agents SDK's explicit compatibility handler and retains stateless JSON
  responses.

### What's New in 0.8.0

- **Single source of truth**: domain logic, tool/server metadata, prompts, and the client parser now live in `src/shared/` and are imported by both the stdio entry (`index.ts`) and the Cloudflare Worker — no more local-vs-remote drift
- **High-level `McpServer` everywhere**: the local stdio server was migrated from the low-level `Server` API to `McpServer`, matching the Worker
- **MCP Prompts**: `contemplate` and `deep-inquiry` for guided contemplative sessions
- **Structured tool output**: tools now return `structuredContent` validated against an `outputSchema`, plus behavioral annotations (`readOnlyHint`, `idempotentHint`, `destructiveHint: false`, `openWorldHint: false`) and a server `instructions` field
- **Theme-aware, accessible UI**: the ext-apps journey visualization adapts to the host light/dark theme and is keyboard-accessible
- **Security & cleanup**: `@modelcontextprotocol/sdk` bumped to `^1.27.1`, `zod` added, `chalk` removed; the legacy Express SSE server (`server.ts`), the `express` deps, and the `Dockerfile` were removed; the repo moved to bun lockfiles. Added a vitest test suite (`tests/`) and a single-source version workflow (`src/shared/version.ts` + `bun run sync-version`)
- **Server icon & website**: `server.json` advertises the remote Worker (`remotes[]`), a `websiteUrl`, and icon `sizes`; the Worker advertises icons/website in the initialize handshake and serves the icon as same-origin bytes at `/icon.png`

### What's New in 0.7.0

- **Fully stateless Worker**: removed the Durable Object — the remote Worker now creates a fresh server per request and relies on the client-driven `previousJourney` parameter for journey continuity (eliminating accumulated SSE wall time)

### What's New in 0.6.0

- **Server icon**: added an icon to `server.json` and the Worker so MCP Registry and claude.ai Connectors display the lotus logo
- **Warmer UI** and (since reverted) experimental Durable Object session state

### What's New in 0.5.0

- **npm + MCP Registry publish**: hardened packaging and published to npm and the official MCP Registry

### What's New in 0.4.0

- **Interactive Visualization**: MCP ext-apps UI renders a "Living Trace" journey inline in supporting clients (Claude Desktop, Cursor, ChatGPT)
- **Completion Fix**: Any tag with `nextStepNeeded=false` now correctly returns `WISDOM_READY` (previously only `express` and `complete` could complete)
- **Cloudflare Worker**: Worker deployment updated with ext-apps resource serving

### What's New in 0.3.2

- 🚪 **Simplified Begin**: `tag='begin'` can now be called with just `{"tag":"begin"}` - all other params auto-filled
- 🤖 **Better Haiku/Small Model Support**: Removes friction for models that don't infer all required params

### What's New in 0.3.1

- 📚 **Complete Framework Learning**: `begin` tag now returns full parameter explanations, response format details, and meditation handling
- 🔢 **Accurate Token Counts**: Updated documentation with actual token measurements (~150 constant, ~1,200 on-demand)

### What's New in 0.3.0

- 🚪 **Begin Tag**: New `tag='begin'` opens the journey—returns full framework before contemplation starts
- ⚡ **Optimized Token Footprint**: Reduced constant context overhead from ~1400 to ~200 tokens while preserving full teaching content
- 🧘 **Learn First, Practice Second**: The `begin` tag ensures models receive complete understanding before contemplating
- 📦 **Updated SDK**: Upgraded to @modelcontextprotocol/sdk 1.23.0

### What's New in 0.2.1

- 📋 **MCP Registry Enhancement**: Added `title` field for better discoverability
- 🎯 **Full Compliance**: Now fully compliant with official MCP publishing guide
- 🔗 **Registry Links**: Available on [Official MCP Registry](https://registry.mcpservers.org/)

### What's New in 0.2.0

- 🌐 **HTTP Transport Support**: Now deployable on smithery.ai and other HTTP-based platforms
- 🔄 **Dual Transport**: Maintains stdio support for npm/CLI users while adding HTTP for remote deployment
- 📦 **Updated SDK**: Upgraded to @modelcontextprotocol/sdk 1.20.1 with Streamable HTTP support
- 🪷 **New Logo**: Terminal-aesthetic lotus logo perfect for developer tools
- ⚡ **Session Management**: HTTP version includes full session management for stateful wisdom journeys

TDQS

A3.5/5.0

Scored across 2 tools

Disambiguation5/5

The two tools have clearly distinct purposes: 'lotuswisdom' is for active contemplative reasoning with a structured workflow, while 'lotuswisdom_summary' is for retrieving a summary of the current journey. There is no overlap or ambiguity between them.

Naming Consistency5/5

Both tools follow a consistent naming pattern with the 'lotuswisdom' prefix and descriptive suffixes ('lotuswisdom' and 'lotuswisdom_summary'). This creates a predictable and readable convention across the tool set.

Tool Count2/5

With only two tools, the server feels under-scoped for its apparent domain of contemplative reasoning and wisdom generation. The core 'lotuswisdom' tool has a complex workflow with many tags, suggesting that additional supporting tools (e.g., for managing or querying specific aspects) would be appropriate to provide a more complete surface.

Completeness2/5

The tool set is severely incomplete for the domain. While 'lotuswisdom' handles the main reasoning process and 'lotuswisdom_summary' provides summaries, there are obvious gaps: no tools for managing or resetting contemplative sessions, querying intermediate states, or handling errors within the complex workflow. This will likely cause agent failures or dead ends.

Maintenance

ActivityNo data
ResponsivenessOutdated data