Yggdrasil MCP
Planned integration for orchestrating workflows through n8n, enabling AI-driven automation pipelines.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Yggdrasil MCP Apply tree-of-thoughts reasoning to evaluate three different database designs"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Yggdrasil MCP
Reasoning orchestration MCP server — Tree of Thoughts with multi-agent evaluation.
A fork of Anthropic's @modelcontextprotocol/server-sequential-thinking with critical bug fixes and an ambitious roadmap for advanced reasoning capabilities.
Why Yggdrasil?
In Norse mythology, Yggdrasil is the World Tree connecting all realms. This MCP embodies that metaphor:
Branches = Different reasoning paths through possibility space
Roots = Deep foundational analysis (first principles)
Connections = Links between thoughts, revisions, and evaluations
Related MCP server: PromptSmith
Key Features
Current (v1.1.0)
6 MCP tools —
sequential_thinking,deep_planning,list_plans,get_plan,promote_plan,archive_plansDescriptive plan naming — Optional
planNameparameter generatesdp-YYYYMMDD-{name}session IDs with duplicate detectionPlan lifecycle management — Promote Claude Code orphan plans, archive old plans, unified discovery across both systems
deep_planning tool — Structured multi-phase planning sessions (init → clarify → explore → evaluate → finalize)
Session resumption — Resume planning sessions by ID with JSONL persistence
Hybrid persistence — JSONL event log + Markdown plan export with JSON index
String coercion fix — Fixes Claude Code bug #3084 where MCP parameters are incorrectly serialized as strings
Oxlint + Biome — 50-100x faster linting, zero-config formatting
Break down complex problems into manageable steps
Revise and refine thoughts as understanding deepens
Branch into alternative paths of reasoning
Adjust the total number of thoughts dynamically
Generate and verify solution hypotheses
Roadmap
See the CLAUDE.md for details:
Mermaid diagram export
Thought history retrieval
Self-evaluation tools
Multi-agent evaluation (cross-model verification)
n8n workflow integration
Installation
Claude Desktop (recommended — one-click install)
Yggdrasil ships as a Claude Desktop Extension (.mcpb):
Download the latest
.mcpb:packages.henrychong.com/yggdrasil-mcp/yggdrasil-mcp-latest.mcpbDouble-click the file — Claude Desktop opens an install dialog → click Install
Restart Claude Desktop
Requires Claude Desktop 1.8000 or later (bundles Node.js 24+).
Optionally verify integrity by comparing the SHA256 against SHA256SUMS:
shasum -a 256 ~/Downloads/yggdrasil-mcp-*.mcpbOlder versions remain available at packages.henrychong.com/yggdrasil-mcp/yggdrasil-mcp-{version}.mcpb.
Claude Cowork / Claude Code (plugin ZIP)
For Cowork / Code, install the plugin ZIP:
# Claude Code — local install
claude --plugin-dir https://packages.henrychong.com/yggdrasil-mcp/yggdrasil-mcp-latest.zipFor Cowork org admins (Teams / Enterprise): upload the ZIP via Organization settings → Plugins → Add plugins → Upload a file. All team members get the tools without further action.
Teams / Enterprise org admins
If your Claude workspace is on a Teams or Enterprise plan, an Owner can distribute Yggdrasil organisation-wide:
Surface | Where | Artefact |
Claude Desktop | Organization settings → Connectors → Desktop → Add custom extension |
|
Claude Cowork | Organization settings → Plugins → Add plugins → Upload a file |
|
Both surface artefacts are attached to every GitHub Release. Mobile / browser-only Cowork remain out of scope (stdio MCP architecturally cannot reach those surfaces).
Claude Code
claude mcp add --scope user yggdrasil "npx -y yggdrasil-mcp"Or add to ~/.claude.json:
{
"mcpServers": {
"yggdrasil": {
"command": "npx",
"args": ["-y", "yggdrasil-mcp"]
}
}
}Claude Desktop
Add to your Claude Desktop config:
{
"mcpServers": {
"yggdrasil": {
"command": "npx",
"args": ["-y", "yggdrasil-mcp"]
}
}
}Local Development
{
"mcpServers": {
"yggdrasil": {
"command": "node",
"args": ["/path/to/yggdrasil-mcp/dist/index.js"]
}
}
}Recommended: CLAUDE.md Configuration
After installing the MCP server, add the following to your ~/.claude/CLAUDE.md (global instructions) to unlock quick-access triggerwords and ensure Claude Code can load the tools correctly.
Why this matters
Yggdrasil tools are deferred tools in Claude Code — their full schemas are not loaded until explicitly fetched. Without the configuration below, Claude Code won't know how to invoke the tools or respond to shorthand triggers. Adding this block enables:
Shorthand triggers (
s1,s2,s3) for instant reasoning at different depth levelsAutomatic ToolSearch so Claude Code loads the tool schema before first use
Correct thought calibration based on problem complexity
Add to ~/.claude/CLAUDE.md
Copy the following block into your ~/.claude/CLAUDE.md file:
## Structured Reasoning (Yggdrasil MCP)
### sequential_thinking — Reflective Problem-Solving
**MANDATORY Trigger:** When `s1`, `s2`, or `s3` appears ANYWHERE in user input:
1. Load via `ToolSearch` query `select:mcp__yggdrasil__sequential_thinking`
2. Invoke with appropriate `totalThoughts`
3. Complete the full chain before responding
**This is NOT optional internal reasoning — you MUST call the external MCP tool.**
| Trigger | totalThoughts | Use Case |
|---------|---------------|----------|
| **s1** | 3-5 | Quick analysis, simple decisions |
| **s2** | 6-10 | Detailed analysis, multi-factor problems |
| **s3** | 12-20 | Comprehensive analysis, complex systems |
### deep_planning — Multi-Phase Planning Sessions
Use for structured planning that needs to track state across phases:
`init → clarify → explore → evaluate → finalize`
Best for: Architecture decisions, multi-approach evaluation, implementation planning with scored trade-offs.
Both tools are deferred — load via `ToolSearch` before first use.ToolSearch (Recommended)
Yggdrasil tools are registered as deferred tools in Claude Code. This means their parameter schemas are not available until fetched via ToolSearch. The CLAUDE.md configuration above handles this automatically for the s1/s2/s3 triggers, but if you want to invoke the tools directly, use:
ToolSearch query: "select:mcp__yggdrasil__sequential_thinking"
ToolSearch query: "select:mcp__yggdrasil__deep_planning"This fetches the full schema and makes the tool callable for the rest of the session.
Verification
After setup, test by typing s1 followed by a question in Claude Code. You should see Claude Code automatically invoke ToolSearch and then call sequential_thinking with 3-5 thoughts.
Tool: sequential_thinking
Facilitates a detailed, step-by-step thinking process for problem-solving and analysis.
Parameters
Required
Parameter | Type | Description |
| string | The current thinking step |
| boolean | Whether another thought step is needed |
| integer | Current thought number (≥1) |
| integer | Estimated total thoughts needed (≥1) |
Optional
Parameter | Type | Description |
| boolean | Whether this revises previous thinking |
| integer | Which thought is being reconsidered |
| integer | Branching point thought number |
| string | Branch identifier |
| boolean | If more thoughts are needed |
Output
{
"thoughtNumber": 3,
"totalThoughts": 5,
"nextThoughtNeeded": true,
"branches": ["branch-a"],
"thoughtHistoryLength": 3
}Tool: deep_planning
Structured planning tool that manages multi-phase planning sessions. Complements sequential_thinking by tracking state while the LLM reasons deeply between phases.
Workflow
init → clarify* → explore+ → evaluate+ → finalize → doneParameters
Parameter | Type | Phases | Description |
| enum | All |
|
| string | init | Problem statement |
| string | init | Descriptive name → |
| string | init | Additional background |
| string | init | JSON array of constraint strings |
| string | clarify | Clarifying question |
| string | clarify | Answer to the question |
| string | explore/evaluate | Unique approach identifier |
| string | explore | Short approach name |
| string | explore | Detailed approach description |
| string | explore | JSON arrays of strings |
| number | evaluate | Score 0-10 |
| number | evaluate | Score 0-10 |
| number | evaluate | Score 0-10 |
| number | evaluate | Score 0-10 (lower is better) |
| string | evaluate | Reasoning for scores |
| string | evaluate |
|
| string | finalize | Branch ID of chosen approach |
| string | finalize | JSON array of step objects |
| string | finalize | JSON array of risk objects |
| string | finalize | JSON array of strings |
| string | finalize | JSON array of strings |
| string | finalize |
|
Output
{
"sessionId": "dp-abc123",
"phase": "explore",
"status": "ok",
"approachCount": 2,
"evaluationCount": 0,
"validNextPhases": ["explore", "evaluate", "clarify"],
"message": "Approach recorded..."
}Plan Management Tools
list_plans
List saved plans with unified view of Yggdrasil plans and Claude Code orphans. Supports pagination, source filtering, and keyword search.
Parameter | Type | Description |
| enum |
|
| string | Case-insensitive search in title/problem text |
| enum |
|
| number | Max results (default 20, max 50) |
| number | Skip first N results (default 0) |
get_plan
Retrieve a saved session by ID. Formats: markdown (default, finalized plans) or jsonl (full event log).
promote_plan
Promote a Claude Code plan file to the Yggdrasil index. Renames the file to YYYYMMDD-{name}.md format and adds it to the index for unified discovery. Includes path traversal protection.
Parameter | Type | Description |
| string | Current CC plan filename (e.g., |
| string | Descriptive name (sanitized to kebab-case) |
archive_plans
Archive old plans by moving files to archive/YYYY/ subdirectory. Supports archiving both Yggdrasil index entries and Claude Code orphan files. Default mode is dry run (preview only).
Parameter | Type | Description |
| number | Archive plans older than N days |
| string | JSON array of specific session IDs |
| enum |
|
| boolean | Preview mode (default: true) |
Use Cases
Yggdrasil is designed for:
Complex problem decomposition — Break down multi-step problems
Iterative planning — Design with room for revision
Course correction — Analysis that adapts as understanding deepens
Scope discovery — Problems where the full scope isn't clear initially
Context maintenance — Tasks requiring state across multiple steps
Information filtering — Situations where irrelevant details need filtering
Configuration
Environment Variables
Variable | Default | Description |
|
| Suppress stderr thought output |
The String Coercion Fix
This fork addresses a critical bug in Claude Code (#3084) where MCP parameters are serialized as strings regardless of their schema type.
The Problem
// Claude Code sends:
{ nextThoughtNeeded: "true", thoughtNumber: "5" }
// Instead of:
{ nextThoughtNeeded: true, thoughtNumber: 5 }Using z.coerce.boolean() is dangerous:
z.coerce.boolean().parse('false'); // Returns TRUE! (non-empty string = truthy)Our Solution
// Safe coercion that correctly handles "false" → false
const coerceBoolean = (val: unknown): boolean => {
if (typeof val === 'boolean') return val;
if (typeof val === 'string') {
if (val.toLowerCase() === 'true') return true;
if (val.toLowerCase() === 'false') return false;
}
throw new Error(`Cannot coerce "${val}" to boolean`);
};
// Applied via z.preprocess (NOT z.coerce)
const booleanSchema = z.preprocess(coerceBoolean, z.boolean());Development
# Install dependencies
pnpm install
# Build
pnpm build
# Run tests
pnpm test
# Lint
pnpm lint
# Format
pnpm format
# Full quality check
pnpm check
# Watch mode
pnpm watchRequirements
Node.js >=24
pnpm (corepack-managed via
packageManagerfield)
Upstream
This is a fork of @modelcontextprotocol/server-sequential-thinking.
We periodically sync relevant changes from upstream while maintaining our string coercion fix and additional features.
Changelog
See CHANGELOG.md for the full version history.
License
MIT License — see LICENSE file for details.
Contributing
Contributions are welcome! See CONTRIBUTING.md for guidelines.
All tests pass (
pnpm test)Linting passes (
pnpm lint)Code is formatted (
pnpm format)Version is incremented appropriately
Available Tools
6 toolsarchive_plansArchive PlansA
Archive old planning sessions by moving files to archive/YYYY/ subdirectory. Default mode is dry run (preview only). Set dryRun to false to execute. Removes archived entries from the Yggdrasil index.
Inputs: dryRun, source, olderThan, sessionIds.
deep_planningDeep PlanningA
A structured planning tool that manages multi-phase planning sessions. Complements sequential_thinking by tracking planning state while the LLM reasons deeply.
Workflow: init → clarify → explore → evaluate → finalize
init: Define the problem, context, and constraints
clarify: Record clarifying questions and answers (repeatable)
explore: Record approach branches with pros/cons (repeatable)
evaluate: Score approaches on feasibility, completeness, coherence, risk (repeatable)
finalize: Select best approach and generate structured implementation plan
Each phase returns valid next phases to guide the workflow. Complex fields (pros, cons, steps, risks, constraints) are passed as JSON strings.
Use sequential_thinking for deep reasoning between phases. Use deep_planning to record conclusions and track planning state.
Inputs: phase (required), cons, name, pros, +21 more.
get_planGet PlanA
Retrieve a saved deep_planning session by its session ID. Returns the plan in the requested format:
"markdown": Rendered Markdown plan (default, only available for finalized plans)
"jsonl": Raw JSONL event log (full session history for reconstruction)
Inputs: sessionId (required), format.
list_plansList PlansA
List saved planning sessions and discovered plan files. Supports optional filters:
status: "complete" (finalized plans) or "in-progress" (active sessions) — Yggdrasil only
keyword: Search in problem/title text (case-insensitive)
source: "yggdrasil" (default), "cc" (Claude Code orphans), or "all"
limit: Maximum results (default 20, max 50)
offset: Skip first N results (default 0)
Returns paginated results sorted by date (newest first).
Inputs: limit, offset, source, status, +1 more.
promote_planPromote PlanA
Promote a Claude Code plan file to the Yggdrasil plans index. Renames the file to YYYYMMDD-{name}.md format and adds it to the index for unified discovery. Only works on .md files not already tracked in the index.
Inputs: name (required), filename (required).
sequential_thinkingSequential ThinkingA
A detailed tool for dynamic and reflective problem-solving through thoughts. This tool helps analyze problems through a flexible thinking process that can adapt and evolve. Each thought can build on, question, or revise previous insights as understanding deepens.
When to use this tool:
Breaking down complex problems into steps
Planning and design with room for revision
Analysis that might need course correction
Problems where the full scope might not be clear initially
Problems that require a multi-step solution
Tasks that need to maintain context over multiple steps
Situations where irrelevant information needs to be filtered out
Key features:
You can adjust total_thoughts up or down as you progress
You can question or revise previous thoughts
You can add more thoughts even after reaching what seemed like the end
You can express uncertainty and explore alternative approaches
Not every thought needs to build linearly - you can branch or backtrack
Generates a solution hypothesis
Verifies the hypothesis based on the Chain of Thought steps
Repeats the process until satisfied
Provides a correct answer
Parameters explained:
thought: Your current thinking step, which can include:
Regular analytical steps
Revisions of previous thoughts
Questions about previous decisions
Realizations about needing more analysis
Changes in approach
Hypothesis generation
Hypothesis verification
nextThoughtNeeded: True if you need more thinking, even if at what seemed like the end
thoughtNumber: Current number in sequence (can go beyond initial total if needed)
totalThoughts: Current estimate of thoughts needed (can be adjusted up/down)
isRevision: A boolean indicating if this thought revises previous thinking
revisesThought: If is_revision is true, which thought number is being reconsidered
branchFromThought: If branching, which thought number is the branching point
branchId: Identifier for the current branch (if any)
needsMoreThoughts: If reaching end but realizing more thoughts needed
You should:
Start with an initial estimate of needed thoughts, but be ready to adjust
Feel free to question or revise previous thoughts
Don't hesitate to add more thoughts if needed, even at the "end"
Express uncertainty when present
Mark thoughts that revise previous thinking or branch into new paths
Ignore information that is irrelevant to the current step
Generate a solution hypothesis when appropriate
Verify the hypothesis based on the Chain of Thought steps
Repeat the process until satisfied with the solution
Provide a single, ideally correct answer as the final output
Only set nextThoughtNeeded to false when truly done and a satisfactory answer is reached
Inputs: thought (required), thoughtNumber (required), totalThoughts (required), nextThoughtNeeded (required), +5 more. Returns: branches, thoughtNumber, totalThoughts, nextThoughtNeeded, +1 more
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
deep_planning and sequential_thinking have overlapping purposes but descriptions clarify the distinction: sequential_thinking is for deep reasoning while deep_planning is for structured planning state tracking. The six tools are otherwise distinct (archive_plans, get_plan, promote_plan, list_plans are clearly separate).
Mostly consistent snake_case with verb_noun patterns (archive_plans, get_plan, list_plans, promote_plan). deep_planning and sequential_thinking deviate slightly as noun phrases, but remain readable and predictable.
Six tools is well-suited for a specialized planning server, covering planning workflow, reasoning, and plan file management without redundancy.
Core lifecycle is covered: planning, reasoning, listing, retrieving, promoting, and archiving. Minor gaps include no delete or export, but these are workable around with existing tools.
Maintenance
Related MCP Connectors
MCP server for building and testing AI agents with multi-model experimentation and insights.
LLM Orchestration Agent (Mcp)
MCP-Native LLM Orchestration Agent
LLM Orchestration MCP Agent
Related MCP Servers
- AlicenseCqualityDmaintenanceA systematic reasoning MCP server for Claude Desktop, featuring Beam Search and Monte Carlo Tree Search to facilitate complex problem-solving and decision-making processes.112MIT
- AlicenseAqualityDmaintenanceAn MCP server that provides 'Reasoning as a Service' by analyzing tasks to select and generate meta-prompts from 40 distinct reasoning frameworks. It enables AI agents to optimize their execution strategy based on task complexity and category, featuring tools for strategy recommendation and performance tracking.51MIT
- AlicenseAqualityDmaintenanceAn MCP server that provides a reasoning sidekick for tool-using agents with a single 'think' tool for tackling complex problems. It allows agents to consult powerful reasoning models like Claude Opus or GPT-5 only when needed, keeping costs low while maintaining control over side effects.13MIT
- AlicenseNot gradedqualityDmaintenanceA powerful MCP server that enhances LLMs with advanced sequential thinking capabilities, supporting 19 thinking modes for structured reasoning and complex cognitive tasks.17MIT