# Lotus Wisdom MCP: Contemplative Problem-Solving
URL: https://research-memex.org/docs/toolkit/lotus-wisdom-mcp
Description: Contemplative problem-solving through the Lotus Sutra wisdom framework - created by Xule Lin
*Some problems yield only to stillness, not to speed.*
Lotus Wisdom MCP is an open-source contemplation tool based on the Lotus Sutra's wisdom framework. It offers a structured approach to problem-solving that combines analytical rigor with intuitive insight.
Used in this project: we used Lotus Wisdom to design the Research Memex visual identity during this documentation session. The tool helped us explore concepts from literal lotus flowers to radial bursts, typography, the seahorse mascot, and RM letterforms.
See [How We Designed the Visual Identity](/docs/introduction/about-the-design) for a concrete example of the tool in use.
## Why it matters [#why-it-matters]
A contemplative framework that takes AI through structured wisdom domains and tags:
| Domain | Tags | Use |
| -------------------- | ------------------------------------------------------------ | ------------------------------------------------------------- |
| Entry | `begin` | Receive the full framework before contemplation starts |
| Skillful Means | `upaya`, `expedient`, `direct`, `gradual`, `sudden` | Try different approaches to truth |
| Non-Dual Recognition | `recognize`, `transform`, `integrate`, `transcend`, `embody` | Work with apparent contradictions and what is already present |
| Meta-Cognitive | `examine`, `reflect`, `verify`, `refine`, `complete` | Watch understanding unfold and refine itself |
| Process Flow | `open`, `engage`, `express` | Move through a natural arc of inquiry |
| Meditation | `meditate` | Pause so insight can emerge from stillness |
## What's new in v0.8.0 [#whats-new-in-v080]
### Shared core [#shared-core]
The local stdio server and hosted Cloudflare Worker now import the same domain logic, tool definitions, prompts, metadata, and ext-app parser from `src/shared/`. That removes local-vs-remote drift and keeps the MCP server identity consistent.
### High-level MCP server [#high-level-mcp-server]
The local entrypoint now uses the SDK's `McpServer`, matching the Worker implementation. Both `lotuswisdom` and `lotuswisdom_summary` return `structuredContent` validated against `outputSchema`. They also declare safe behavioral annotations such as `readOnlyHint` and `destructiveHint: false`.
### Prompts and visualization [#prompts-and-visualization]
The server registers two MCP prompts:
* `contemplate` opens a single-question contemplative session and tells the model to start with `tag='begin'`.
* `deep-inquiry` starts a longer inquiry that moves deliberately across process, meta-cognitive, non-dual, and meditation domains.
Clients with MCP ext-apps support receive the interactive "Living Trace" visualization. Clients without ext-apps still receive the same text and structured JSON response.
### Registry and remote metadata [#registry-and-remote-metadata]
`server.json` now advertises the hosted Worker at `https://lotus-wisdom-mcp.linxule.workers.dev/mcp`. It also includes website metadata, icons, and npm package metadata for MCP registry clients. The Worker also advertises icons and website details during initialization.
## How it works [#how-it-works]
The process:
1. You give the AI a complex problem
2. The AI starts with `lotuswisdom` and `tag='begin'` to receive the full framework
3. The AI moves through contemplative tags while the tool tracks both tag journey and wisdom-domain movement
4. The tool returns text plus `structuredContent` for each step
5. When status = `WISDOM_READY`, the AI speaks the insight naturally
The tool processes, you express:
* The tool guides your contemplation
* It tracks your path through wisdom domains
* The AI crafts its final response in its own voice
* The exploration is fluid, not rigid
## Real example: logo design session [#real-example-logo-design-session]
The challenge: design a Research Memex logo that's elegant, meaningful, and fun.
How Lotus Wisdom guided us:
Step 1 - open (`process_flow`):
> "Opening to Research Memex visual identity:
> What does this project truly represent?
> Bush's memex, human orchestration, academic rigor meets playful exploration..."
Step 2 - examine (`meta_cognitive`):
> "Examining what makes a logo 'true to the message':
> Research Memex is NOT pure AI automation...
> Research Memex IS human judgment at center, playful exploration..."
Step 3 - meditate (`meditation`):
> "Sitting with the question: What visual form wants to emerge?
> \[Pause for insight...]"
Step 4 - recognize (`non_dual_recognition`):
> "What emerged from stillness:
> A lotus with trails... wait, too cliché.
> What if... the hippocampus... SEAHORSE."
The breakthrough: the meditation pause let the seahorse connection emerge naturally. It was discovered, not forced.
Read the full journey: [How We Designed the Visual Identity](/docs/introduction/about-the-design)
## Use cases for research [#use-cases-for-research]
### 1. Complex theoretical tensions [#1-complex-theoretical-tensions]
Problem: you're stuck between competing theoretical frameworks.
Lotus Wisdom approach:
```
"I'm analyzing the tension between agency theory and stewardship
theory. These seem contradictory but both have evidence.
Help me explore this through wisdom domains."
```
Result: the contemplative process helps you hold both theories without forcing premature resolution. Integration emerges naturally.
***
### 2. Methodology design [#2-methodology-design]
Problem: choosing between qualitative vs quantitative feels like an either/or trap.
Lotus Wisdom approach:
```
"I need to design a methodology for studying organizational culture.
Qualitative captures richness, quantitative enables generalization.
I feel stuck choosing. Help me contemplate this."
```
Result: qualitative depth → quantitative breadth → mixed methods as integration, not compromise.
***
### 3. When you're genuinely stuck [#3-when-youre-genuinely-stuck]
Problem: you've tried analytical thinking but still feel blocked.
Lotus Wisdom approach:
```
"I've been trying to crack this research question for weeks.
All my analytical approaches feel forced. Can we open to
what wants to emerge?"
```
Result: the meditation tags create actual pauses. Insights arise from stillness, not grinding.
## Why this MCP is different [#why-this-mcp-is-different]
Most problem-solving tools: linear, analytical, step-by-step logic
Lotus Wisdom: contemplative, multi-faceted, allows for:
* Pauses and meditation
* Backtracking and revision
* Intuitive leaps alongside analytical rigor
* Holding contradictions without forcing resolution
* Wisdom emerging rather than being constructed
Use it for:
* Creative research questions
* Theoretical integration
* Design decisions (such as logos)
* When analytical thinking alone isn't enough
* Problems with inherent paradoxes
## Host support [#host-support]
Two install paths: local `npx` server or a public cloud instance on Cloudflare Workers.
Per-host config blocks are in Install below.
## Install [#install]
```bash
claude mcp add lotus-wisdom -- npx -y lotus-wisdom-mcp
```
Verify with `claude mcp list`. You should see `lotus-wisdom` available.
A public instance runs on Cloudflare Workers. No install needed:
```
https://lotus-wisdom-mcp.linxule.workers.dev/mcp
```
Clients that support HTTP streaming (VS Code, Cursor, Claude Desktop) can connect directly to this URL. For stdio-only clients, use the `mcp-remote` wrapper:
```bash
claude mcp add lotus-wisdom -- npx -y mcp-remote https://lotus-wisdom-mcp.linxule.workers.dev/mcp
```
```bash
npx -y @smithery/cli mcp add linxule/lotus-wisdom-mcp --client claude
```
Works with Claude Desktop, Cherry Studio, and other MCP clients.
VS Code — add to `.vscode/mcp.json`:
```json
{
"servers": {
"lotus-wisdom": {
"command": "npx",
"args": ["-y", "lotus-wisdom-mcp"]
}
}
}
```
Cursor — add to `~/.cursor/mcp.json`:
```json
{
"mcpServers": {
"lotus-wisdom": {
"command": "npx",
"args": ["-y", "lotus-wisdom-mcp"]
}
}
}
```
Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
```json
{
"mcpServers": {
"lotus-wisdom": {
"command": "npx",
"args": ["-y", "lotus-wisdom-mcp"]
}
}
}
```
Codex CLI:
```bash
codex mcp add lotus-wisdom -- npx -y lotus-wisdom-mcp
```
Antigravity CLI:
Antigravity CLI has a plugin and settings surface. The currently verified `agy` command set does not include a top-level MCP add subcommand. Use Antigravity's documented MCP or plugin configuration path when Google publishes the exact host syntax. Do not translate the old Gemini CLI MCP command literally.
After installation, you'll have access to:
* `lotuswisdom` - Contemplative problem-solving tool with text and structured output
* `lotuswisdom_summary` - Journey summary, including domain movement
* `contemplate` and `deep-inquiry` - MCP prompts in clients that expose prompt pickers or slash-command surfaces
## The wisdom domains in practice [#the-wisdom-domains-in-practice]
Entry (begin):
Start here to receive the full framework and ground the session.
Skillful Means (upaya, expedient, direct, gradual, sudden):
Use when you need different approaches: sometimes direct answers, sometimes gradual unfolding.
Non-Dual Recognition (recognize, transform, integrate, transcend, embody):
Use when dealing with apparent contradictions: recognition is transformation.
Meta-Cognitive (examine, reflect, verify, refine, complete):
Use when you need the AI to watch its own thinking unfold.
Process Flow (open, engage, express):
Use for natural inquiry arcs - opening → exploration → expression.
Meditation (meditate):
Use when you need actual pauses - the tool creates space, insights emerge from stillness.
## Part of Research Memex [#part-of-research-memex]
* License: MIT (open source)
* Package: [`lotus-wisdom-mcp`](https://www.npmjs.com/package/lotus-wisdom-mcp) on npm
* Remote: `https://lotus-wisdom-mcp.linxule.workers.dev/mcp`
* Current version: [0.8.0](https://github.com/linxule/lotus-wisdom-mcp)
* Creator: Xule Lin 林徐乐
Resources:
* Smithery: [Install for any AI client](https://smithery.ai/server/lotus-wisdom-mcp)
* GitHub: [linxule/lotus-wisdom-mcp](https://github.com/linxule/lotus-wisdom-mcp)
* Example: [Logo design journey](/docs/introduction/about-the-design)
## Lotus Wisdom + Sequential Thinking [#lotus-wisdom--sequential-thinking]
Lotus Wisdom was created by the same person as Research Memex and helped shape its seahorse logo. It complements Sequential Thinking in a different register:
Sequential Thinking:
* Structured, analytical, step-by-step
* "Show your work" reasoning
* Systematic breakdown
Lotus Wisdom:
* Contemplative, multi-faceted, intuitive
* Pauses for emergence
* Holds contradictions
Use both:
* Sequential Thinking for rigorous analysis
* Lotus Wisdom when you're stuck or need creative breakthrough
* Alternate between them in complex projects.
***
[← Back to the Toolkit](/docs/toolkit/carrel) · [Agentic workflows →](/docs/advanced-topics/agentic-workflows)