lotus-wisdom-mcp 0.1.2 → 0.2.0

package/README.md

@@ -5,12 +5,14 @@
 </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.
+
 ## 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
 * Beautifully formatted thought process visualization with colors and symbols
+* Tracks both tag journey and wisdom domain movements
 * Final integration of insights into a clear response
 
 ## Background
@@ -21,27 +23,36 @@ Note: The original prompt framework may work less effectively with newer Claude
 
 ## Implementation Details
 
-The server implements a structured thinking process using the following components:
+The server implements a structured thinking process using wisdom domains inspired by the Lotus Sutra:
+
+### Wisdom Domains and Tags
+
+The server organizes thoughts using five wisdom domains (all valid values for the `tag` input parameter):
+
+* **Skillful Means** (🔆): `upaya`, `expedient`, `direct`, `gradual`, `sudden`
+  - Different approaches to truth - sometimes direct pointing, sometimes gradual unfolding
 
-### Tag Types
+* **Non-Dual Recognition** (☯️): `recognize`, `transform`, `integrate`, `transcend`, `embody`
+  - Aspects of awakening to what's already present - recognition IS transformation
 
-The server organizes thoughts using various tag categories (all valid values for the `tag` input parameter):
+* **Meta-Cognitive** (🧠): `examine`, `reflect`, `verify`, `refine`, `complete`
+  - The mind watching its own understanding unfold
 
-* **Skillful Means**: upaya, expedient, direct, gradual, sudden
-* **Non-Dual Recognition**: recognize, transform, integrate, transcend, embody
-* **Meta-Cognitive Awareness**: examine, reflect, verify, refine, complete
-* **Process Steps**: open, engage, transform, express, meditate
-* **Final Output**: OUTPUT
+* **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
 
 Each thought is beautifully formatted with:
 
 * Colorful output using the chalk library
-* Tag-specific symbols (e.g., 🔆 for skillful means, ☯️ for non-dual recognition)
+* Domain-specific symbols and colors
 * Box-drawing characters to create clear thought boundaries
 * Special meditation formatting with pause indicators
-* Final output with double-line borders for emphasis
+* Journey tracking showing both tag path and domain movements
 
 Note: The visualization appears in the server console output, helping developers track the thinking process.
 
@@ -50,10 +61,12 @@ Note: The visualization appears in the server console output, helping developers
 1. The user submits a problem to solve
 2. The model works through a sequence of thoughts using different tags
 3. Each thought builds on previous ones and may revise understanding
-4. Meditation pauses can be included for clarity
-5. The process concludes with a final OUTPUT thought
+4. The tool tracks both the tag journey and wisdom domain movements
+5. Meditation pauses can be included for clarity
+6. When status='WISDOM_READY' is returned, the tool's work is complete
+7. The model then expresses the final wisdom naturally in its own voice
 
-## Tool
+## Available Tools
 
 ### lotuswisdom
 
@@ -61,13 +74,29 @@ A tool for problem-solving using the Lotus Sutra's wisdom framework, with variou
 
 **Inputs:**
 
-* `tag` (string): The current processing technique (must be one of the core tags listed above)
-* `content` (string): The content of the current processing step
-* `stepNumber` (integer): Current number in sequence
-* `totalSteps` (integer): Estimated total steps needed
-* `nextStepNeeded` (boolean): Whether another step is needed
+* `tag` (string, required): The current processing technique (must be one of the tags listed above)
+* `content` (string, required): The content of the current processing step
+* `stepNumber` (integer, required): Current number in sequence
+* `totalSteps` (integer, required): Estimated total steps needed
+* `nextStepNeeded` (boolean, required): Whether another step is needed
 * `isMeditation` (boolean, optional): Whether this step is a meditative pause
-* `meditationDuration` (integer, optional): Duration for meditation in seconds
+* `meditationDuration` (integer, optional): Duration for meditation in seconds (1-10)
+
+**Returns:**
+- Processing status with current step information, wisdom domain, and journey tracking
+- `MEDITATION_COMPLETE` status for meditation steps
+- `WISDOM_READY` status when the contemplative process is complete
+
+### lotuswisdom_summary
+
+Get a summary of the current contemplative journey.
+
+**Inputs:** None
+
+**Returns:**
+- Journey length
+- Domain journey showing movement between wisdom domains
+- Summary of all steps with their tags, domains, and brief content
 
 ## Usage
 
@@ -133,18 +162,18 @@ Here's how a conversation with Claude might flow when using the Lotus Wisdom MCP
 }
 ```
 
-5. Provide a final output:
+5. Express the final understanding:
 ```json
 {
-  "tag": "OUTPUT",
-  "content": "Freedom and responsibility exist in dynamic balance. Freedom is the power to choose, while responsibility is accountability for those choices. They're not opposing forces but complementary aspects of human agency. Without freedom, responsibility would be mere obligation. Without responsibility, freedom would degrade into impulsivity. The most fulfilled lives embrace both: using freedom to make meaningful choices while taking responsibility for their consequences.",
+  "tag": "express",
+  "content": "The paradox resolves when we see that authentic freedom includes responsibility as its natural expression.",
   "stepNumber": 5,
   "totalSteps": 5,
   "nextStepNeeded": false
 }
 ```
 
-The result would be a thoughtful, multi-perspective response to the question that shows the process of arriving at wisdom rather than just stating conclusions.
+When the tool returns `status: 'WISDOM_READY'`, Claude then speaks the final wisdom naturally, integrating all the insights from the contemplative journey.
 
 ## Configuration
 
@@ -152,7 +181,25 @@ The result would be a thoughtful, multi-perspective response to the question tha
 
 Add this to your `claude_desktop_config.json`:
 
-#### From npm (recommended)
+#### From Smithery (recommended for easy installation)
+
+```json
+{
+  "mcpServers": {
+    "lotus-wisdom": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@smithery/server-linxule-lotus-wisdom-mcp"
+      ]
+    }
+  }
+}
+```
+
+Or install directly via [Smithery.ai](https://smithery.ai/server/@linxule/lotus-wisdom-mcp)
+
+#### From npm
 
 ```json
 {
@@ -184,7 +231,7 @@ Add this to your `claude_desktop_config.json`:
 }
 ```
 
-#### docker
+#### Docker
 
 ```json
 {
@@ -202,45 +249,66 @@ Add this to your `claude_desktop_config.json`:
 }
 ```
 
-## Building
+### Building
 
-Docker:
+To build the project locally:
 
+```bash
+npm install
+npm run build
 ```
+
+To build the Docker image:
+
+```bash
 docker build -t lotus-wisdom-mcp -f Dockerfile .
 ```
 
-## License
+### Development
 
-This MCP server is licensed under the MIT License. For more details, please see the LICENSE file in the project repository.
+For local development:
 
-## Connect from Claude Desktop
+```bash
+npm install
+npm run dev
+```
 
-Since Claude Desktop doesn't yet have native support for remote MCP servers with authentication, you'll need to use the `mcp-remote` proxy:
+Enable debug mode by setting the environment variable:
 
-1. Update your Claude Desktop configuration file:
-   - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
-   - Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+```bash
+LOTUS_DEBUG=true npm start
+```
 
-2. Add the following configuration:
+## How It Works
 
-```json
-{
-  "mcpServers": {
-    "lotus-wisdom": {
-      "command": "npx",
-      "args": ["mcp-remote", "https://lotus-wisdom-mcp.linxule.workers.dev/sse"]
-    }
-  }
-}
-```
+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:
 
-3. Restart Claude Desktop (Cmd/Ctrl + R)
+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.
 
-4. When Claude restarts, a browser window will open for OAuth authentication. Complete the authorization flow to grant Claude access to the MCP server.
+2. **Journey Consciousness**: The tool maintains awareness of your complete journey, showing both the sequence of tags used and the movement between wisdom domains.
 
-5. Once authenticated, you'll see the Lotus Wisdom tools available in Claude's tool menu (bottom right corner).
+3. **Non-Linear Progress**: While steps are numbered, the process isn't strictly linear. You can revisit, revise, and branch as understanding deepens.
 
-## Available Tools
+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.
+
+## 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.2.0
+
+### What's New in 0.2.0
 
-// ... existing code ... 
+- 🌐 **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