---

name: sequential-thinking category: integration-connectivity/mcp-integrations version: 1.0.0 description: Complete guide to using Sequential Thinking MCP server with Claude Code author: blackbox5/mcp verified: true tags: [mcp, sequential-thinking, reasoning, problem-solving]

Sequential Thinking MCP Server Skills

Package: @modelcontextprotocol/server-sequential-thinking Purpose: Enhanced reasoning and problem decomposition

Sequential Thinking is a reasoning framework that breaks down complex problems into manageable steps, makes reasoning explicit and traceable, reduces errors through systematic analysis, improves decision-making through structured thought, and enhances problem-solving with methodical approaches.

For simple tasks (file operations, basic lookups), Sequential Thinking is not needed. Use it for complex problem solving, root cause analysis, code review, and trade-off analysis.

<available_skills> <skill_group name="Problem Decomposition"> Break a complex problem into smaller steps Break down the authentication flow Complex problem to solve Relevant context and constraints Step-by-step breakdown, dependencies between steps, estimated complexity, potential risks </skill_group>

<skill_group name="Logical Reasoning"> Apply logical reasoning to reach conclusions Reason through this bug Starting facts or observations What to reason about Known constraints Logical steps, intermediate conclusions, final conclusion, confidence level Create a chain of thought for a problem Think through this feature request Initial problem or question How deep to explore (default: thorough) Step-by-step reasoning, alternatives considered, trade-offs analyzed, recommended approach </skill_group>

<skill_group name="Decision Making"> Make a decision by analyzing options Decide between React and Vue Array of options to consider Evaluation criteria Importance of each criteria (optional) Ranked options, pros and cons of each, recommendation with reasoning, risk assessment </skill_group>

<skill_group name="Analysis"> Analyze root causes of a problem Find root cause of this bug Description of the problem Observable symptoms System context Possible causes, most likely root cause, investigation steps, verification method Assess risks in a plan or approach Assess risks in this deployment Plan or approach to assess System or business context Identified risks, likelihood and impact, mitigation strategies, acceptance criteria </skill_group>

<skill_group name="Solution Design"> Design a solution step by step Design a solution for user authentication What the solution must achieve Technical or business constraints Additional factors to consider Solution architecture, implementation steps, risks and mitigations, testing strategy Design or analyze an algorithm Design a sorting algorithm Algorithmic problem to solve Performance or functional requirements Space or time constraints Algorithm steps, time complexity, space complexity, optimization opportunities </skill_group>

<skill_group name="Code Analysis"> Review code with systematic analysis Review this function for bugs Code to review Specific focus area (security, performance, bugs) Issues found, severity levels, fix suggestions, best practice violations Debug issues systematically Debug this error step by step Error message or unexpected behavior Relevant code Runtime context Possible causes, investigation steps, likely fix, prevention strategies </skill_group> </available_skills>

<best_practices> Break complex problems into steps Make reasoning explicit Consider multiple approaches Validate assumptions Document thought process Learn from mistakes Jump to conclusions Skip steps Ignore alternatives Overlook edge cases Forget to verify Make unwarranted assumptions Use for complex problem solving Use for architecture decisions Use for algorithm design Use for root cause analysis Use for code review Use for simple file operations Use for straightforward code changes Use for information lookup Use for basic questions </best_practices>

<error_handling> Reasoning seems off State assumptions clearly Verify each step Check for logical fallacies Consider alternative perspectives Stuck on problem Break it down further Try different approach Gather more information Take a step back Too many options Define evaluation criteria Rank by importance Eliminate clearly bad options Compare remaining options </error_handling>

<output_format> Problem Breakdown Hierarchical list of steps with dependencies and complexity estimates Logical Reasoning Chain of reasoning steps from premise to conclusion with confidence level Decision Analysis Ranked options with pros/cons, scores, and recommendation Solution Design Architecture overview with implementation steps and risk assessment </output_format>

<integration_notes> Use Sequential Thinking for: Complex problem solving, architecture decisions, algorithm design, root cause analysis, code review, debugging complex issues, risk assessment, trade-off analysis. Quick tasks may not need it: Simple file operations, straightforward code changes, information lookup, basic questions. Deductive: General rules → Specific case → Conclusion. Inductive: Specific cases → Patterns → General rule. Abductive: Outcome → Hypotheses → Most likely explanation. Design Thinking: Empathize → Define → Ideate → Prototype → Test. </integration_notes>