# 1194 2025 11 01 Claude Desktop Troubleshooting 0ff9062b

> Session Learning Capture: Claude Desktop Troubleshooting & Configuration Optimization

- Skill: `tools-only/1194-2025-11-01-claude-desktop-troubleshooting-0ff9062b` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add tools-only/1194-2025-11-01-claude-desktop-troubleshooting-0ff9062b`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tools-only/1194-2025-11-01-claude-desktop-troubleshooting-0ff9062b/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tools-only (https://skillmd.com/u/tools-only)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/tools-only/1194-2025-11-01-claude-desktop-troubleshooting-0ff9062b

---

# Session Learning Capture: Claude Desktop Troubleshooting & Configuration Optimization

**Date:** 2025-11-01
**Session Type:** Debugging & System Configuration
**Skill Used:** learning-capture
**ROI Estimate:** 500+ tokens saved per similar incident × 5-10 future occurrences = 2500-5000 tokens

---

## 📋 Session Summary

Successfully debugged Claude Desktop crashes caused by AWS MCP Server and optimized the overall MCP/Extensions configuration through systematic troubleshooting and critical analysis of installed components.

---

## 🎯 Novel Problem-Solving Approaches

### Pattern 1: Dual-Location MCP Server Configuration
**Problem:** User reported persistent "AWS MCP Server connection failed" errors despite removing it from `claude_desktop_config.json`

**Discovery:** Claude Desktop has TWO separate systems for server integration:
1. **MCP Servers** → `claude_desktop_config.json` (manual JSON configuration)
2. **Claude Extensions** → `extensions-installations.json` + directory tree (registry-based)

**Critical Insight:** The AWS server was installed as BOTH:
- MCP Server (removed first)
- Claude Extension (actual source of error messages)

**Solution Pattern:**
```
1. Check claude_desktop_config.json (MCP Servers)
2. Check extensions-installations.json (Extensions Registry)
3. Check Claude Extensions/ directory (Actual files)
4. Check Claude Extensions Settings/ directory (Extension configs)
5. Remove from ALL locations for complete removal
```

**Generalization:** When debugging Claude Desktop server issues, ALWAYS check both MCP and Extensions systems. They are independent and can contain duplicate installations.

**Files to Check:**
```
C:\Users\[User]\AppData\Roaming\Claude\
├── claude_desktop_config.json          ← MCP Servers
├── extensions-installations.json       ← Extensions Registry
├── Claude Extensions\                  ← Extension Files
└── Claude Extensions Settings\         ← Extension Configs
```

---

### Pattern 2: Log-Driven Root Cause Analysis
**Approach:** Used systematic log analysis to identify crash source

**Method:**
1. Identify crash symptoms from user report
2. Search for server-specific logs: `mcp-server-aws-api.log`
3. Analyze error patterns:
   - "Server transport closed unexpectedly"
   - "Server disconnected"
   - DeprecationWarnings in Python code
4. Cross-reference with config files to find registration
5. Complete removal from all locations

**Key Logs for Claude Desktop Debugging:**
```
C:\Users\[User]\AppData\Roaming\Claude\logs\
├── mcp.log                    ← Main MCP log (errors, connections)
├── mcp-server-[name].log      ← Individual server logs
└── Crashpad\reports\          ← Crash dumps
```

**Pattern Signature:**
- Log size correlates with problematic servers (aws-api: 256KB of errors)
- "Server transport closed unexpectedly" = server crash/compatibility issue
- DeprecationWarnings = version incompatibility

---

### Pattern 3: Critical Analysis of "Useful" vs. "Overhead" Components
**Context:** User had memory + sequential-thinking MCP servers installed

**Analysis Framework:**
1. **Practical Value Test:**
   - Does it solve a real problem?
   - Is the benefit observable/measurable?
   - Can the user verify it's working?

2. **Transparency Test:**
   - Can the user see what it's doing?
   - Is stored data accessible?
   - Can it be debugged/modified?

3. **Redundancy Test:**
   - Does existing system already provide this?
   - (e.g., `.claude/projects/` for history, `AGENT_MEMORY.md` for memory)

**Decision Matrix:**
| Server | Practical Value | Transparency | Redundancy | Verdict |
|--------|----------------|--------------|------------|---------|
| memory | Theoretical | Black Box | High (projects/, AGENT_MEMORY.md) | ❌ Remove |
| sequential-thinking | Theoretical | Black Box | High (native thinking mode) | ❌ Remove |
| everything | High (filesystem) | Clear | Low | ✅ Keep |
| browser | High (automation) | Clear | Low | ✅ Keep |
| code-runner | High (execution) | Clear | Low | ✅ Keep |
| notion | High (integration) | Clear | Low | ✅ Keep |

**Guideline:** Prefer transparent, single-purpose tools over opaque "smart" systems.

---

## 🔄 Repeated Patterns (Session-Specific)

### Pattern: Backup Before Modification
**Occurred:** 2 times (config backups)
**Implementation:**
```bash
cp config.json "config.backup.$(date +%Y%m%d_%H%M%S).json"
```

**Lesson:** Always create timestamped backups before config changes. Enables safe experimentation and quick rollback.

---

## 📚 Domain-Specific Knowledge

### Claude Desktop Architecture
**Knowledge Type:** System Understanding (stable, high reuse potential)

**Key Concepts:**
1. **MCP (Model Context Protocol) Servers:**
   - Defined in `claude_desktop_config.json`
   - Node-based (require paths to .js files)
   - Manual installation/configuration

2. **Claude Extensions:**
   - Registry-based system (`extensions-installations.json`)
   - Can be Python or Node-based
   - Include metadata, manifests, signatures
   - Installed via Claude Desktop UI or CLI

3. **Configuration Hierarchy:**
   ```
   settings.json           → Global settings (permissions, plugins)
   claude_desktop_config.json → MCP servers
   extensions-installations.json → Extensions registry
   ```

4. **Permission Modes:**
   - `bypassPermissions` → Operations execute without confirmation
   - `alwaysThinkingEnabled` → Deep analysis mode

**Cost Savings:** Explaining this architecture costs ~300 tokens. Capturing it saves future explanations.

---

## 💡 Effective Reasoning Patterns

### Pattern: "Systematic Narrowing" for Configuration Issues
**Structure:**
1. **Gather Symptoms** (error messages, crash timing)
2. **Identify Scope** (MCP? Extension? Both?)
3. **Locate Evidence** (logs, config files)
4. **Cross-Reference** (config ↔ logs ↔ directory structure)
5. **Remove & Verify** (complete cleanup, test)

**Why Better Than Alternatives:**
- Random trial-and-error → wastes time, incomplete fixes
- Grepping alone → misses registry/directory issues
- This approach → comprehensive, root cause resolution

**Reproducible Template:**
```
Problem: [Error message]
↓
Check: [All config locations]
↓
Evidence: [Log analysis showing root cause]
↓
Action: [Remove from ALL locations]
↓
Verify: [No more errors]
```

---

## 🔧 Workflow Optimizations

### Optimization 1: Parallel Tool Calls for Independent Checks
**Old Approach:**
```
Read config.json
Read extensions.json
Read logs/mcp.log
```
(Sequential, 3 round-trips)

**Optimized Approach:**
```
[Read config.json, Read extensions.json, Bash logs/mcp.log]
```
(Parallel, 1 round-trip)

**Savings:** 2 round-trips × ~200 tokens overhead = 400 tokens per diagnostic session

---

### Optimization 2: Skills Selection Framework
**Context:** Evaluated 10 meta-skills for usefulness

**Framework Developed:**
1. **Match to User's Actual Work:**
   - User's focus: React/Vite projects, AI/Data
   - Meta-skill development? No
   - → Skip skill-development skills

2. **Immediate Practical Benefit:**
   - Token Budget Advisor → Yes (manages context limits)
   - Security Analyzer → Yes (production apps need security)
   - Continual Learning → Yes (captures patterns like THIS ONE)
   - Doc Generator → Maybe (documentation automation)

3. **Overhead vs. Value:**
   - Too many skills → slower startup, confusing
   - Right amount (3-4) → high value, low overhead

**Guideline:** Install 3-4 high-impact skills, not 10+ theoretical ones.

---

## 📊 ROI Calculation

### This Learning Capture
**Investment:**
- Session time: ~45 minutes
- Capture documentation: ~15 minutes
- **Total: ~60 minutes, ~3000 tokens**

**Expected Returns:**
- Similar Claude Desktop issues: 5-10 occurrences over next year
- Time saved per occurrence: 30-45 minutes
- Tokens saved per occurrence: 500-800 tokens
- **Total savings: 2.5-7.5 hours, 2500-8000 tokens**

**ROI Ratio:** 1:5 to 1:10 (time), 1:1 to 1:3 (tokens)

---

## 🎓 Key Learnings for Future Sessions

### Decision Rules Established

1. **When Debugging Claude Desktop Crashes:**
   - ✅ Check BOTH MCP and Extensions systems
   - ✅ Analyze logs for size + error patterns
   - ✅ Remove from ALL config locations
   - ✅ Backup configs before changes

2. **When Evaluating MCP Servers/Extensions:**
   - ❌ Avoid: Black box, theoretical benefit, redundant
   - ✅ Keep: Transparent, practical, unique capability

3. **When Installing Skills:**
   - Target: 3-4 high-impact skills
   - Avoid: Meta-skills unless doing skill development
   - Prioritize: Direct project work support

---

## 🔗 Related Patterns

**Related to:**
- System configuration debugging
- Software component evaluation
- Tool selection frameworks
- Log analysis methodologies

**Could combine with:**
- React project troubleshooting patterns
- Dependency conflict resolution
- Development environment optimization

---

## 📝 Reusable Templates

### Template 1: Claude Desktop Crash Investigation
```markdown
## Crash Investigation Checklist

### 1. Symptom Collection
- [ ] Error messages
- [ ] Crash timing (startup/runtime)
- [ ] Recent config changes

### 2. MCP Server Check
- [ ] Review `claude_desktop_config.json`
- [ ] Check `logs/mcp-server-*.log` for errors
- [ ] Look for "transport closed" or "disconnected"

### 3. Extensions Check
- [ ] Review `extensions-installations.json`
- [ ] Check `Claude Extensions/` directory
- [ ] Check `Claude Extensions Settings/` configs

### 4. Log Analysis
- [ ] Sort logs by size (larger = more errors)
- [ ] Search for DeprecationWarnings
- [ ] Identify problematic server/extension

### 5. Complete Removal
- [ ] Backup configs
- [ ] Remove from MCP config (if applicable)
- [ ] Remove from Extensions registry
- [ ] Delete extension directory
- [ ] Delete extension settings
- [ ] Restart Claude Desktop
- [ ] Verify error gone
```

### Template 2: Component Evaluation Matrix
```markdown
| Component | Practical Value | Transparency | Redundancy | Startup Cost | Verdict |
|-----------|-----------------|--------------|------------|--------------|---------|
| [Name]    | High/Med/Low    | Clear/Opaque | High/Low   | Fast/Slow    | Keep/Remove |
```

---

## 🚀 Application Scenarios

**Use this pattern when:**
- Claude Desktop crashes or shows connection errors
- MCP server/extension behaving unexpectedly
- Deciding which tools to install/keep
- Optimizing Claude Desktop performance
- Troubleshooting configuration issues

**Context indicators:**
- Error message contains "server", "transport", "connection"
- Claude Desktop startup is slow
- Too many inactive/unknown servers installed
- User asking about tool selection

---

## ✅ Session Outcomes

**Problems Solved:**
1. ✅ Claude Desktop crashes → AWS Extension removed
2. ✅ "AWS connection failed" errors → Completely eliminated
3. ✅ Bloated configuration → Optimized (9 servers → 4 essential)
4. ✅ Opaque memory system → Replaced with transparent learning-capture skill

**Artifacts Created:**
1. ✅ Optimized `claude_desktop_config.json`
2. ✅ Cleaned `extensions-installations.json`
3. ✅ Skills installation (4 high-value skills)
4. ✅ Skills documentation (`README.md`)
5. ✅ This learning capture document

**Knowledge Captured:**
1. ✅ Claude Desktop architecture (MCP vs Extensions)
2. ✅ Debugging methodology (systematic narrowing)
3. ✅ Component evaluation framework
4. ✅ Skills selection guidelines

---

**Next Session Using This Pattern:**
When similar configuration/crash issues arise, reference this document to:
- Skip re-learning the MCP vs Extensions distinction
- Apply proven debugging checklist
- Use established evaluation criteria
- Avoid repeating time-consuming trial-and-error

**Estimated Time Savings:** 30-45 minutes per similar issue
**Estimated Token Savings:** 500-800 tokens per similar session