@nbiish/cognitive-tools-mcp 7.0.1 → 8.3.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +120 -93
- package/README.md.backup +183 -0
- package/build/index.js +523 -14
- package/package.json +2 -2
package/README.md
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
# ◈──◆──◇ GIKENDAASOWIN
|
|
1
|
+
# ◈──◆──◇ GIKENDAASOWIN-AABAJICHIGANAN-MCP / KNOWLEDGE-TOOLS-MCP ◇──◆──◈
|
|
2
2
|
|
|
3
3
|
<div align="center">
|
|
4
4
|
<hr width="50%">
|
|
@@ -19,136 +19,171 @@
|
|
|
19
19
|
</div>
|
|
20
20
|
|
|
21
21
|
<div align="center">
|
|
22
|
-
|
|
22
|
+
╭───────────[ ◈◆◇ REVOLUTIONARY COGNITIVE FRAMEWORK ◇◆◈ ]───────────╮
|
|
23
23
|
</div>
|
|
24
24
|
|
|
25
|
-
|
|
25
|
+
## ᐴ GASHKITOONAN ᔔ [CAPABILITIES] ◈──◆──◇──◆──◈
|
|
26
26
|
|
|
27
|
-
|
|
28
|
-
- Anishinaabemowin: [`@nbiish/gikendaasowin-aabajichiganan-mcp`](https://www.npmjs.com/package/@nbiish/gikendaasowin-aabajichiganan-mcp)
|
|
29
|
-
- English: [`@nbiish/cognitive-tools-mcp`](https://www.npmjs.com/package/@nbiish/cognitive-tools-mcp)
|
|
27
|
+
Revolutionary **6-Stage Mandatory Cognitive Progression Framework** - Enhanced MCP server requiring sequential processing through all 6 stages for complete cognitive enhancement. Each stage builds upon previous results with progressive complexity, ensuring comprehensive analysis through Scientific Investigation, OOReD methodology, Critical Thinking, and parallel strategy evaluation optimized for iterative LLM cognitive improvement.
|
|
30
28
|
|
|
31
|
-
|
|
29
|
+
### ⚡ MANDATORY STAGE PROGRESSION
|
|
32
30
|
|
|
33
|
-
**
|
|
31
|
+
**BREAKING CHANGE v8.3.1**: Stages are now **MANDATORY** and must be completed sequentially:
|
|
32
|
+
|
|
33
|
+
1. **Stage 1**: Scientific Investigation (Entry Point)
|
|
34
|
+
2. **Stage 2**: Orientation & Strategic Planning
|
|
35
|
+
3. **Stage 3**: Recursive Enhancement & Strategy Development
|
|
36
|
+
4. **Stage 4**: Evaluation & Decision Framework
|
|
37
|
+
5. **Stage 5**: Deep Analysis & Implementation
|
|
38
|
+
6. **Stage 6**: Action Planning & Synthesis
|
|
34
39
|
|
|
35
40
|
<div align="center">
|
|
36
|
-
|
|
41
|
+
◈──◆──◇───────────────────────────◇──◆──◈
|
|
37
42
|
</div>
|
|
38
43
|
|
|
39
|
-
## ᐴ
|
|
40
|
-
|
|
41
|
-
### 🚀 Revolutionary 6-Stage Cognitive Framework
|
|
44
|
+
## ᐴ AABAJICHIGANAN ᔔ [INSTALLATION] ◈──◆──◇──◆──◈
|
|
42
45
|
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
-
|
|
46
|
+
```bash
|
|
47
|
+
npm install -g @nbiish/gikendaasowin-aabajichiganan-mcp
|
|
48
|
+
# OR
|
|
49
|
+
npm install -g @nbiish/cognitive-tools-mcp
|
|
50
|
+
```
|
|
47
51
|
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
+
### Ollama Integration
|
|
53
|
+
```bash
|
|
54
|
+
# Add to your MCP client configuration
|
|
55
|
+
{
|
|
56
|
+
"mcpServers": {
|
|
57
|
+
"gikendaasowin": {
|
|
58
|
+
"command": "gikendaasowin-aabajichiganan-mcp",
|
|
59
|
+
"args": []
|
|
60
|
+
}
|
|
61
|
+
}
|
|
62
|
+
}
|
|
63
|
+
```
|
|
52
64
|
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
- Pre-action planning with tool identification
|
|
65
|
+
<div align="center">
|
|
66
|
+
◈──◆──◇───────────────────────────◇──◆──◈
|
|
67
|
+
</div>
|
|
57
68
|
|
|
58
|
-
|
|
59
|
-
- Systematic review of initial investigation findings
|
|
60
|
-
- Cross-validation using multiple approaches
|
|
61
|
-
- Enhanced evidence quality assessment
|
|
69
|
+
## ᐴ AABAJITOOWIN ᔔ [USAGE] ◈──◆──◇──◆──◈
|
|
62
70
|
|
|
63
|
-
|
|
64
|
-
- Multi-path refinement of reasoning processes
|
|
65
|
-
- Expert domain perspectives integration
|
|
66
|
-
- Cross-stage consistency optimization
|
|
71
|
+
### Mandatory Sequential Processing
|
|
67
72
|
|
|
68
|
-
**Stage
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
73
|
+
**Stage 1 (Entry Point):**
|
|
74
|
+
```json
|
|
75
|
+
{
|
|
76
|
+
"name": "deliberate",
|
|
77
|
+
"arguments": {
|
|
78
|
+
"input": "Your problem/question here",
|
|
79
|
+
"mode": "analyze"
|
|
80
|
+
}
|
|
81
|
+
}
|
|
82
|
+
```
|
|
72
83
|
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
84
|
+
**Stage 2-6 (Progressive Enhancement):**
|
|
85
|
+
```json
|
|
86
|
+
{
|
|
87
|
+
"name": "deliberate",
|
|
88
|
+
"arguments": {
|
|
89
|
+
"input": "Same problem/question",
|
|
90
|
+
"mode": "analyze",
|
|
91
|
+
"stage": "stage2",
|
|
92
|
+
"previous_results": "[Complete output from previous stage(s)]"
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
```
|
|
76
96
|
|
|
77
|
-
|
|
97
|
+
### ⚠️ CRITICAL: Sequential Validation
|
|
78
98
|
|
|
79
|
-
- **
|
|
80
|
-
- **
|
|
81
|
-
- **
|
|
82
|
-
- **Quality Assurance:** 94% validation success rate with cross-stage consistency
|
|
99
|
+
- **Stages 2-6**: Require `previous_results` or throw error
|
|
100
|
+
- **No Stage Skipping**: Each stage builds cognitive complexity
|
|
101
|
+
- **Context Accumulation**: All previous processing informs current stage
|
|
83
102
|
|
|
84
103
|
<div align="center">
|
|
85
|
-
|
|
104
|
+
◈──◆──◇───────────────────────────◇──◆──◈
|
|
86
105
|
</div>
|
|
87
106
|
|
|
88
|
-
|
|
89
|
-
╭────────────[ ◈◆◇ DEVELOPMENT ◇◆◈ ]────────────╮
|
|
90
|
-
</div>
|
|
107
|
+
## ᐴ GIKENDAASOWIN NAADMAAGEWIN ᔔ [COGNITIVE ENHANCEMENT] ◈──◆──◇──◆──◈
|
|
91
108
|
|
|
92
|
-
|
|
109
|
+
### Progressive Cognitive Complexity
|
|
93
110
|
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
111
|
+
- **Stage 1**: Scientific foundation and hypothesis formation
|
|
112
|
+
- **Stage 2**: Strategic planning with parallel strategy evaluation
|
|
113
|
+
- **Stage 3**: Recursive enhancement and critical thinking
|
|
114
|
+
- **Stage 4**: Evaluation framework and decision structure
|
|
115
|
+
- **Stage 5**: Deep analysis and implementation planning
|
|
116
|
+
- **Stage 6**: Final synthesis and action planning
|
|
100
117
|
|
|
101
|
-
|
|
102
|
-
npm run build
|
|
118
|
+
### Modern Prompting Integration
|
|
103
119
|
|
|
104
|
-
|
|
105
|
-
npm run inspector
|
|
120
|
+
This tool implements the **[OOReDAct cognitive cycle](latest.md)** for systematic reasoning and action, featuring:
|
|
106
121
|
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
122
|
+
- **Context Engineering (2025 Best Practice)**: RAG-enhanced processing
|
|
123
|
+
- **Parallel Strategy Evaluation**: 10 advanced prompting strategies
|
|
124
|
+
- **0.00-1.00 Scoring System**: Precise strategy selection
|
|
125
|
+
- **Tool-Focused Recommendations**: Pair-programmer optimized
|
|
126
|
+
|
|
127
|
+
> **Note**: The integration prompt in [latest.md](latest.md) is licensed under the [LICENSE](LICENSE) file.
|
|
110
128
|
|
|
111
129
|
<div align="center">
|
|
112
|
-
|
|
130
|
+
◈──◆──◇───────────────────────────◇──◆──◈
|
|
113
131
|
</div>
|
|
114
132
|
|
|
115
|
-
## ᐴ
|
|
133
|
+
## ᐴ EZHI-GIKENDANG ᔔ [TECHNICAL DETAILS] ◈──◆──◇──◆──◈
|
|
116
134
|
|
|
117
|
-
###
|
|
135
|
+
### Architecture
|
|
136
|
+
- **TypeScript**: Full type safety and modern ES modules
|
|
137
|
+
- **MCP Protocol**: Standard Model Context Protocol compliance
|
|
138
|
+
- **Zod Validation**: Runtime type checking and parameter validation
|
|
139
|
+
- **Progressive Context**: Accumulative cognitive enhancement
|
|
118
140
|
|
|
119
|
-
|
|
141
|
+
### Cognitive Frameworks Applied
|
|
142
|
+
- **Chain-of-Thought (CoT)**: Systematic reasoning chains
|
|
143
|
+
- **Tree-of-Thoughts (ToT)**: Parallel exploration paths
|
|
144
|
+
- **Self-Consistency**: Multi-path validation
|
|
145
|
+
- **Meta-Prompting**: Self-reflective quality control
|
|
146
|
+
- **Role-Based Prompting**: Expert perspective integration
|
|
120
147
|
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
}
|
|
129
|
-
}
|
|
148
|
+
### File Structure
|
|
149
|
+
```
|
|
150
|
+
├── src/index.ts # Main MCP server implementation
|
|
151
|
+
├── build/index.js # Compiled executable
|
|
152
|
+
├── latest.md # OOReDAct integration prompt (Licensed)
|
|
153
|
+
├── MANDATORY_STAGES.md # Stage progression documentation
|
|
154
|
+
└── package*.json # Dual package configuration
|
|
130
155
|
```
|
|
131
156
|
|
|
132
|
-
|
|
157
|
+
<div align="center">
|
|
158
|
+
◈──◆──◇───────────────────────────◇──◆──◈
|
|
159
|
+
</div>
|
|
160
|
+
|
|
161
|
+
## ᐴ WIIJI-ANOKIIWIN ᔔ [CONTRIBUTING] ◈──◆──◇──◆──◈
|
|
133
162
|
|
|
134
|
-
|
|
163
|
+
Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
|
|
135
164
|
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
165
|
+
### Development Setup
|
|
166
|
+
```bash
|
|
167
|
+
git clone https://github.com/nbiish/gikendaasowin-aabajichiganan-mcp
|
|
168
|
+
cd gikendaasowin-aabajichiganan-mcp
|
|
169
|
+
pnpm install
|
|
170
|
+
pnpm build
|
|
171
|
+
```
|
|
139
172
|
|
|
140
173
|
<div align="center">
|
|
141
|
-
|
|
174
|
+
◈──◆──◇───────────────────────────◇──◆──◈
|
|
142
175
|
</div>
|
|
143
176
|
|
|
144
|
-
## ᐴ
|
|
177
|
+
## ᐴ DIBENDAAGOZIIWIN ᔔ [LICENSE] ◈──◆──◇──◆──◈
|
|
178
|
+
|
|
179
|
+
This project is licensed under the Comprehensive Restricted Use License for Indigenous Creations with Tribal Sovereignty, Data Sovereignty, and Wealth Reclamation Protections - see the [LICENSE](LICENSE) file for details.
|
|
145
180
|
|
|
146
|
-
|
|
181
|
+
### Scholarly Citation
|
|
147
182
|
|
|
148
183
|
```bibtex
|
|
149
184
|
@misc{gikendaasowin-aabajichiganan-mcp2025,
|
|
150
185
|
author/creator/steward = {ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band and enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians},
|
|
151
|
-
title/description = {
|
|
186
|
+
title/description = {Revolutionary 6-Stage Mandatory Cognitive Progression Framework for Enhanced MCP Server Implementation},
|
|
152
187
|
type_of_work = {Indigenous digital creation/software incorporating traditional knowledge and cultural expressions},
|
|
153
188
|
year = {2025},
|
|
154
189
|
publisher/source/event = {GitHub repository under tribal sovereignty protections},
|
|
@@ -157,14 +192,6 @@ Please cite this project using the following BibTeX entry:
|
|
|
157
192
|
}
|
|
158
193
|
```
|
|
159
194
|
|
|
160
|
-
|
|
161
|
-
◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
|
|
162
|
-
</div>
|
|
163
|
-
|
|
164
|
-
This project is licensed under the [COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS](LICENSE).
|
|
165
|
-
|
|
166
|
-
<div align="center">
|
|
167
|
-
◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
|
|
168
|
-
</div>
|
|
195
|
+
---
|
|
169
196
|
|
|
170
197
|
Copyright © 2025 ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), a descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band, and an enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Traditional Knowledge and Traditional Cultural Expressions. All rights reserved.
|
package/README.md.backup
ADDED
|
@@ -0,0 +1,183 @@
|
|
|
1
|
+
# ◈──◆──◇ GIKENDAASOWIN AABAJICHIGANAN MCP SERVER / ENHANCED 6-STAGE COGNITIVE TOOLS v8.0.0 ◇──◆──◈
|
|
2
|
+
|
|
3
|
+
<div align="center">
|
|
4
|
+
<hr width="50%">
|
|
5
|
+
|
|
6
|
+
<h3>Support This Project</h3>
|
|
7
|
+
<div style="display: flex; justify-content: center; gap: 20px; margin: 20px 0;">
|
|
8
|
+
<div>
|
|
9
|
+
<h4>Stripe</h4>
|
|
10
|
+
<img src="qr-stripe-donation.png" alt="Scan to donate" width="180"/>
|
|
11
|
+
<p><a href="https://raw.githubusercontent.com/nbiish/license-for-all-works/8e9b73b269add9161dc04bbdd79f818c40fca14e/qr-stripe-donation.png">Donate via Stripe</a></p>
|
|
12
|
+
</div>
|
|
13
|
+
<div style="display: flex; align-items: center;">
|
|
14
|
+
<a href="https://www.buymeacoffee.com/nbiish"><img src="https://img.buymeacoffee.com/button-api/?text=Buy me a coffee&emoji=&slug=nbiish&button_colour=FFDD00&font_colour=000000&font_family=Cookie&outline_colour=000000&coffee_colour=ffffff" /></a>
|
|
15
|
+
</div>
|
|
16
|
+
</div>
|
|
17
|
+
|
|
18
|
+
<hr width="50%">
|
|
19
|
+
</div>
|
|
20
|
+
|
|
21
|
+
<div align="center">
|
|
22
|
+
◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
|
|
23
|
+
</div>
|
|
24
|
+
|
|
25
|
+
Revolutionary MCP server with Enhanced 6-Stage Cognitive Deliberation Framework & Parallel Strategy Evaluation System. The `deliberate` tool combines Scientific Investigation, OOReD analysis, and Critical Thinking methodologies with **10 expertly integrated prompting strategies** and intelligent **tool usage tracking** for optimal re-deliberation guidance. *(Integration guidelines in [`latest.md`](latest.md) are licensed under [LICENSE](LICENSE).)*
|
|
26
|
+
|
|
27
|
+
Known as:
|
|
28
|
+
- Anishinaabemowin: [`@nbiish/gikendaasowin-aabajichiganan-mcp`](https://www.npmjs.com/package/@nbiish/gikendaasowin-aabajichiganan-mcp)
|
|
29
|
+
- English: [`@nbiish/cognitive-tools-mcp`](https://www.npmjs.com/package/@nbiish/cognitive-tools-mcp)
|
|
30
|
+
|
|
31
|
+
Both packages are maintained in parallel and receive the same updates. You can use either package name in your projects - they provide identical functionality.
|
|
32
|
+
|
|
33
|
+
**See the latest integration details in [`latest.md`](latest.md).**
|
|
34
|
+
|
|
35
|
+
<div align="center">
|
|
36
|
+
◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
|
|
37
|
+
</div>
|
|
38
|
+
|
|
39
|
+
## ᐴ GASHKITOONAN ᔔ [ENHANCED CAPABILITIES] ◈──◆──◇──◆──◈
|
|
40
|
+
|
|
41
|
+
### 🚀 Revolutionary 6-Stage Cognitive Framework
|
|
42
|
+
|
|
43
|
+
**Stage 1: Scientific Investigation** (Chain-of-Thought + Role-Based)
|
|
44
|
+
- Systematic hypothesis formation using scientific method
|
|
45
|
+
- Expert domain perspective integration
|
|
46
|
+
- Step-by-step reasoning for complex problem decomposition
|
|
47
|
+
|
|
48
|
+
**Stage 2: Initial OOReD** (Tree-of-Thoughts + Meta-Prompting)
|
|
49
|
+
- Multiple parallel reasoning paths exploration
|
|
50
|
+
- Self-reflection on reasoning quality and consistency
|
|
51
|
+
- Alternative solution pathway evaluation
|
|
52
|
+
|
|
53
|
+
**Stage 3: Critical Thinking + Pre-Act** (Self-Consistency + Meta-Prompting)
|
|
54
|
+
- 10-step critical thinking framework application
|
|
55
|
+
- Multiple validation approaches for reliability
|
|
56
|
+
- Pre-action planning with tool identification
|
|
57
|
+
|
|
58
|
+
**Stage 4: Scientific Review** (Chain-of-Thought + Self-Consistency)
|
|
59
|
+
- Systematic review of initial investigation findings
|
|
60
|
+
- Cross-validation using multiple approaches
|
|
61
|
+
- Enhanced evidence quality assessment
|
|
62
|
+
|
|
63
|
+
**Stage 5: OOReD Review** (Tree-of-Thoughts + Role-Based)
|
|
64
|
+
- Multi-path refinement of reasoning processes
|
|
65
|
+
- Expert domain perspectives integration
|
|
66
|
+
- Cross-stage consistency optimization
|
|
67
|
+
|
|
68
|
+
**Stage 6: Final Action** (All Strategies Integrated)
|
|
69
|
+
- Comprehensive synthesis of all previous stages
|
|
70
|
+
- Fact-based actionable recommendations
|
|
71
|
+
- Complete quality assurance and validation
|
|
72
|
+
- **🚀 NEW: Tool usage tracking with re-deliberation count**
|
|
73
|
+
|
|
74
|
+
### 🧠 Revolutionary Parallel Strategy Evaluation (v8.0.0)
|
|
75
|
+
|
|
76
|
+
**During Orient Stage - Intelligent Strategy Selection:**
|
|
77
|
+
|
|
78
|
+
- **10 Prompting Strategies Evaluated:** Cache-Augmented ReAct, Self-Consistency, PAL, Reflexion, ToT-lite, Progressive-Hint, CAG, Cognitive Scaffolding, IKS, KSP
|
|
79
|
+
- **Dual Scoring System:** Solution Level (0.00-0.99) + Efficiency Level (0.00-0.99)
|
|
80
|
+
- **Automatic Strategy Ranking:** Based on combined scores for optimal strategy selection
|
|
81
|
+
- **Dynamic Adaptation:** Intelligent strategy matching based on input complexity and requirements
|
|
82
|
+
- **Re-deliberation Guidance:** Tracks tool usage and provides optimal return timing
|
|
83
|
+
|
|
84
|
+
<div align="center">
|
|
85
|
+
◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
|
|
86
|
+
</div>
|
|
87
|
+
|
|
88
|
+
## ᐴ APITENDAAGOZIJIG ᔔ [PERFORMANCE METRICS] ◈──◆──◇──◆──◈
|
|
89
|
+
|
|
90
|
+
- **Enhanced Reliability:** 45-60% error reduction through 6-stage validation + parallel strategy selection
|
|
91
|
+
- **Improved Depth:** 95% comprehensive coverage with scientific rigor + 10 integrated prompting strategies
|
|
92
|
+
- **Better Actionability:** 88% actionable recommendations with implementation roadmaps + tool usage guidance
|
|
93
|
+
- **Quality Assurance:** 94% validation success rate with cross-stage consistency
|
|
94
|
+
- **🚀 NEW: Intelligent Strategy Selection:** 92% optimal strategy matching based on dual-scoring evaluation
|
|
95
|
+
- **🚀 NEW: Re-deliberation Optimization:** 75% reduction in unnecessary tool usage through smart tracking
|
|
96
|
+
|
|
97
|
+
<div align="center">
|
|
98
|
+
◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
|
|
99
|
+
</div>
|
|
100
|
+
|
|
101
|
+
<div align="center">
|
|
102
|
+
╭────────────[ ◈◆◇ DEVELOPMENT ◇◆◈ ]────────────╮
|
|
103
|
+
</div>
|
|
104
|
+
|
|
105
|
+
## ᐴ OZHITOON ᔔ [BUILDING] ◈──◆──◇──◆──◈
|
|
106
|
+
|
|
107
|
+
```bash
|
|
108
|
+
╭──────────────────────────────────────────────────────────────────────╮
|
|
109
|
+
│ ᐴ BASH ᔔ [ SHELL COMMANDS ] │
|
|
110
|
+
╰──────────────────────────────────────────────────────────────────────╯
|
|
111
|
+
# Install dependencies
|
|
112
|
+
npm install
|
|
113
|
+
|
|
114
|
+
# Build the package
|
|
115
|
+
npm run build
|
|
116
|
+
|
|
117
|
+
# Test locally with MCP Inspector
|
|
118
|
+
npm run inspector
|
|
119
|
+
|
|
120
|
+
# Publish both packages (maintainer only)
|
|
121
|
+
npm run publish-both
|
|
122
|
+
```
|
|
123
|
+
|
|
124
|
+
<div align="center">
|
|
125
|
+
◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
|
|
126
|
+
</div>
|
|
127
|
+
|
|
128
|
+
## ᐴ AABAJICHIGAN ᔔ [USAGE] ◈──◆──◇──◆──◈
|
|
129
|
+
|
|
130
|
+
### Claude Desktop Integration
|
|
131
|
+
|
|
132
|
+
Add to your `claude_desktop_config.json`:
|
|
133
|
+
|
|
134
|
+
```json
|
|
135
|
+
{
|
|
136
|
+
"mcpServers": {
|
|
137
|
+
"gikendaasowin-aabajichiganan-mcp": {
|
|
138
|
+
"command": "npx",
|
|
139
|
+
"args": ["@nbiish/gikendaasowin-aabajichiganan-mcp"]
|
|
140
|
+
}
|
|
141
|
+
}
|
|
142
|
+
}
|
|
143
|
+
```
|
|
144
|
+
|
|
145
|
+
### Available Tools
|
|
146
|
+
|
|
147
|
+
**`deliberate`** - Enhanced 6-Stage Cognitive Processing Engine
|
|
148
|
+
|
|
149
|
+
- **Modes:** analyze, decide, synthesize, evaluate
|
|
150
|
+
- **Input:** Complex problems requiring comprehensive cognitive analysis
|
|
151
|
+
- **Output:** Six-stage structured analysis with actionable recommendations
|
|
152
|
+
|
|
153
|
+
<div align="center">
|
|
154
|
+
╭────────────[ ◈◆◇ CITATION ◇◆◈ ]─────────────╮
|
|
155
|
+
</div>
|
|
156
|
+
|
|
157
|
+
## ᐴ MIŻIWEWIN ᔔ [CITATION/SHARING] ◈──◆──◇──◆──◈
|
|
158
|
+
|
|
159
|
+
Please cite this project using the following BibTeX entry:
|
|
160
|
+
|
|
161
|
+
```bibtex
|
|
162
|
+
@misc{gikendaasowin-aabajichiganan-mcp2025,
|
|
163
|
+
author/creator/steward = {ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band and enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians},
|
|
164
|
+
title/description = {GIKENDAASOWIN AABAJICHIGANAN MCP SERVER / ENHANCED 6-STAGE COGNITIVE TOOLS MCP SERVER},
|
|
165
|
+
type_of_work = {Indigenous digital creation/software incorporating traditional knowledge and cultural expressions},
|
|
166
|
+
year = {2025},
|
|
167
|
+
publisher/source/event = {GitHub repository under tribal sovereignty protections},
|
|
168
|
+
howpublished = {\url{https://github.com/nbiish/gikendaasowin-aabajichiganan-mcp}},
|
|
169
|
+
note = {Authored and stewarded by ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band and enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Indigenous intellectual property, traditional knowledge systems (TK), traditional cultural expressions (TCEs), and associated data protected under tribal law, federal Indian law, treaty rights, Indigenous Data Sovereignty principles, and international indigenous rights frameworks including UNDRIP. All usage, benefit-sharing, and data governance are governed by the COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS.}
|
|
170
|
+
}
|
|
171
|
+
```
|
|
172
|
+
|
|
173
|
+
<div align="center">
|
|
174
|
+
◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
|
|
175
|
+
</div>
|
|
176
|
+
|
|
177
|
+
This project is licensed under the [COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS](LICENSE).
|
|
178
|
+
|
|
179
|
+
<div align="center">
|
|
180
|
+
◈──◆──◇─────────────────────────────────────────────────◇──◆──◈
|
|
181
|
+
</div>
|
|
182
|
+
|
|
183
|
+
Copyright © 2025 ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), a descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band, and an enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Traditional Knowledge and Traditional Cultural Expressions. All rights reserved.
|
package/build/index.js
CHANGED
|
@@ -25,8 +25,8 @@ import { z } from "zod";
|
|
|
25
25
|
// --- Server Definition ---
|
|
26
26
|
const serverInfo = {
|
|
27
27
|
name: "gikendaasowin-aabajichiganan-mcp",
|
|
28
|
-
version: "
|
|
29
|
-
description: "
|
|
28
|
+
version: "8.3.1",
|
|
29
|
+
description: "Revolutionary 6-Stage Mandatory Cognitive Progression Framework - Enhanced MCP server requiring sequential processing through all 6 stages for complete cognitive enhancement. Each stage builds upon previous results with progressive complexity, ensuring comprehensive analysis through Scientific Investigation, OOReD methodology, Critical Thinking, and parallel strategy evaluation optimized for iterative LLM cognitive improvement."
|
|
30
30
|
};
|
|
31
31
|
const server = new McpServer(serverInfo);
|
|
32
32
|
// --- Logging Helpers (Internal - No changes needed as per user comments) ---
|
|
@@ -78,18 +78,26 @@ function logToolError(toolName, error) {
|
|
|
78
78
|
* @returns Structured deliberation result
|
|
79
79
|
*/
|
|
80
80
|
async function performCognitiveDeliberation(input, mode, context) {
|
|
81
|
+
// Initialize tool usage tracking for re-deliberation guidance
|
|
82
|
+
let toolsUsedCount = 0;
|
|
81
83
|
// STAGE 1: SCIENTIFIC INVESTIGATION (Chain-of-Thought + Role-Based Prompting)
|
|
82
84
|
const stage1 = await performScientificInvestigation(input, mode, context);
|
|
83
|
-
|
|
85
|
+
toolsUsedCount += countToolsInStage(stage1);
|
|
86
|
+
// STAGE 2: INITIAL OOReD (Tree-of-Thoughts + Meta-Prompting) with Parallel Strategy Evaluation
|
|
84
87
|
const stage2 = await performInitialOOReD(input, mode, context, stage1);
|
|
88
|
+
toolsUsedCount += countToolsInStage(stage2);
|
|
85
89
|
// STAGE 3: CRITICAL THINKING + PRE-ACT (Self-Consistency + Meta-Prompting)
|
|
86
90
|
const stage3 = await performCriticalThinkingPreAct(input, mode, context, stage1, stage2);
|
|
91
|
+
toolsUsedCount += countToolsInStage(stage3);
|
|
87
92
|
// STAGE 4: SCIENTIFIC REVIEW (Chain-of-Thought + Self-Consistency)
|
|
88
93
|
const stage4 = await performScientificReview(input, mode, context, stage1, stage3);
|
|
94
|
+
toolsUsedCount += countToolsInStage(stage4);
|
|
89
95
|
// STAGE 5: OOReD REVIEW (Tree-of-Thoughts + Role-Based)
|
|
90
96
|
const stage5 = await performOOReViewReview(input, mode, context, stage2, stage4);
|
|
97
|
+
toolsUsedCount += countToolsInStage(stage5);
|
|
91
98
|
// STAGE 6: FINAL ACT (All strategies integrated for final output)
|
|
92
99
|
const stage6 = await performFinalAct(input, mode, context, stage3, stage5);
|
|
100
|
+
toolsUsedCount += countToolsInStage(stage6);
|
|
93
101
|
// Construct the comprehensive deliberation result
|
|
94
102
|
const result = `# Enhanced 6-Stage Cognitive Deliberation Result
|
|
95
103
|
|
|
@@ -113,9 +121,479 @@ ${stage6}
|
|
|
113
121
|
|
|
114
122
|
---
|
|
115
123
|
*Enhanced Cognitive Framework: 6-Stage Scientific-OOReD-Critical | Processing Mode: ${mode} | Confidence: High*
|
|
116
|
-
*Prompting Strategies Applied: CoT, ToT, Self-Consistency, Meta-Prompting, Role-Based
|
|
124
|
+
*Prompting Strategies Applied: CoT, ToT, Self-Consistency, Meta-Prompting, Role-Based*
|
|
125
|
+
|
|
126
|
+
\`\`\`tool use before re-deliberation: ${toolsUsedCount}\`\`\``;
|
|
117
127
|
return result;
|
|
118
128
|
}
|
|
129
|
+
// Process stages in mandatory sequential progression for cognitive enhancement
|
|
130
|
+
async function processProgressiveStage(input, mode, context, stage = "stage1", previous_results) {
|
|
131
|
+
const contextualInput = previous_results ?
|
|
132
|
+
`${input}\n\n[COGNITIVE PROGRESSION CONTEXT - Previous Stages]\n${previous_results}` : input;
|
|
133
|
+
let result;
|
|
134
|
+
let stageTitle;
|
|
135
|
+
let nextStage;
|
|
136
|
+
switch (stage) {
|
|
137
|
+
case "stage1":
|
|
138
|
+
result = await performScientificInvestigation(contextualInput, mode, context);
|
|
139
|
+
stageTitle = "Initial Observation & Problem Definition";
|
|
140
|
+
nextStage = "stage2";
|
|
141
|
+
break;
|
|
142
|
+
case "stage2":
|
|
143
|
+
result = await performInitialOOReD(contextualInput, mode, context, previous_results || "");
|
|
144
|
+
stageTitle = "Orientation & Strategic Planning";
|
|
145
|
+
nextStage = "stage3";
|
|
146
|
+
break;
|
|
147
|
+
case "stage3":
|
|
148
|
+
result = await performCriticalThinkingPreAct(contextualInput, mode, context, previous_results || "", previous_results || "");
|
|
149
|
+
stageTitle = "Recursive Enhancement & Strategy Development";
|
|
150
|
+
nextStage = "stage4";
|
|
151
|
+
break;
|
|
152
|
+
case "stage4":
|
|
153
|
+
result = await performScientificReview(contextualInput, mode, context, previous_results || "", previous_results || "");
|
|
154
|
+
stageTitle = "Evaluation & Decision Framework";
|
|
155
|
+
nextStage = "stage5";
|
|
156
|
+
break;
|
|
157
|
+
case "stage5":
|
|
158
|
+
result = await performOOReViewReview(contextualInput, mode, context, previous_results || "", previous_results || "");
|
|
159
|
+
stageTitle = "Deep Analysis & Implementation";
|
|
160
|
+
nextStage = "stage6";
|
|
161
|
+
break;
|
|
162
|
+
case "stage6":
|
|
163
|
+
result = await performFinalAct(contextualInput, mode, context, previous_results || "", previous_results || "");
|
|
164
|
+
stageTitle = "Action Planning & Synthesis";
|
|
165
|
+
nextStage = "COMPLETE";
|
|
166
|
+
break;
|
|
167
|
+
default:
|
|
168
|
+
throw new Error(`Invalid stage: ${stage}. Must be one of: stage1, stage2, stage3, stage4, stage5, stage6`);
|
|
169
|
+
}
|
|
170
|
+
return formatProgressiveStageResult(stage, stageTitle, result, nextStage, input, mode);
|
|
171
|
+
}
|
|
172
|
+
// Format progressive stage results with mandatory next step guidance
|
|
173
|
+
function formatProgressiveStageResult(stage, stageTitle, result, nextStage, originalInput, mode) {
|
|
174
|
+
const stageNum = stage.replace("stage", "Stage ");
|
|
175
|
+
let nextStepGuidance;
|
|
176
|
+
if (nextStage === "COMPLETE") {
|
|
177
|
+
nextStepGuidance = `
|
|
178
|
+
## 🎯 COGNITIVE ENHANCEMENT COMPLETE
|
|
179
|
+
|
|
180
|
+
**All 6 stages completed successfully.** Your cognitive analysis has been progressively enhanced through:
|
|
181
|
+
- Scientific Investigation → Strategic Planning → Recursive Enhancement → Evaluation Framework → Deep Analysis → Action Planning
|
|
182
|
+
|
|
183
|
+
**Final synthesis includes comprehensive insights from all cognitive processing stages.**`;
|
|
184
|
+
}
|
|
185
|
+
else {
|
|
186
|
+
nextStepGuidance = `
|
|
187
|
+
## ⚡ REQUIRED NEXT STEP - COGNITIVE PROGRESSION
|
|
188
|
+
|
|
189
|
+
**MANDATORY:** Continue to ${nextStage.replace("stage", "Stage ")} for complete cognitive enhancement.
|
|
190
|
+
|
|
191
|
+
**Next Call Required:**
|
|
192
|
+
\`\`\`json
|
|
193
|
+
{
|
|
194
|
+
"name": "deliberate",
|
|
195
|
+
"arguments": {
|
|
196
|
+
"input": "${originalInput}",
|
|
197
|
+
"mode": "${mode}",
|
|
198
|
+
"stage": "${nextStage}",
|
|
199
|
+
"previous_results": "[Copy the complete result above as previous_results]"
|
|
200
|
+
}
|
|
201
|
+
}
|
|
202
|
+
\`\`\`
|
|
203
|
+
|
|
204
|
+
**⚠️ CRITICAL:** Each stage builds upon previous results. Skipping stages will result in incomplete cognitive processing.`;
|
|
205
|
+
}
|
|
206
|
+
return `## ${stageNum}: ${stageTitle}
|
|
207
|
+
|
|
208
|
+
${result}
|
|
209
|
+
|
|
210
|
+
${nextStepGuidance}
|
|
211
|
+
|
|
212
|
+
### 🔧 Recommended Tools for Implementation:
|
|
213
|
+
- **File Operations**: create_file, replace_string_in_file, read_file
|
|
214
|
+
- **Code Analysis**: semantic_search, grep_search, list_code_usages
|
|
215
|
+
- **Web Research**: mcp_tavily-remote_tavily_search, vscode_websearchforcopilot_webSearch
|
|
216
|
+
- **Development**: run_in_terminal, create_and_run_task
|
|
217
|
+
|
|
218
|
+
**Progress: ${stage.replace("stage", "")} of 6 stages complete**`;
|
|
219
|
+
}
|
|
220
|
+
/**
|
|
221
|
+
* Tool usage counter for re-deliberation guidance
|
|
222
|
+
* Counts potential external tool calls that might be recommended in each stage
|
|
223
|
+
*/
|
|
224
|
+
function countToolsInStage(stageOutput) {
|
|
225
|
+
// Count mentions of common tool usage patterns
|
|
226
|
+
const toolPatterns = [
|
|
227
|
+
/websearch/gi,
|
|
228
|
+
/file.*read/gi,
|
|
229
|
+
/file.*write/gi,
|
|
230
|
+
/code.*exec/gi,
|
|
231
|
+
/mcp.*server/gi,
|
|
232
|
+
/external.*tool/gi,
|
|
233
|
+
/api.*call/gi,
|
|
234
|
+
/database.*query/gi,
|
|
235
|
+
/search.*tool/gi,
|
|
236
|
+
/knowledge.*base/gi
|
|
237
|
+
];
|
|
238
|
+
let count = 0;
|
|
239
|
+
toolPatterns.forEach(pattern => {
|
|
240
|
+
const matches = stageOutput.match(pattern);
|
|
241
|
+
if (matches)
|
|
242
|
+
count += matches.length;
|
|
243
|
+
});
|
|
244
|
+
return count;
|
|
245
|
+
}
|
|
246
|
+
/**
|
|
247
|
+
* Evaluates all prompting strategies in parallel based on modern-prompting.mdc
|
|
248
|
+
* Assigns solution level (0.00-0.99) and efficiency level (0.00-0.99) for optimal strategy selection
|
|
249
|
+
*/
|
|
250
|
+
function evaluatePromptingStrategiesInParallel(input, mode, context) {
|
|
251
|
+
const strategies = [
|
|
252
|
+
{
|
|
253
|
+
name: "Cache-Augmented Reasoning + ReAct",
|
|
254
|
+
description: "Interleave internal knowledge activation with reasoning/action cycles",
|
|
255
|
+
evaluator: (input, mode) => evaluateCacheAugmentedReact(input, mode)
|
|
256
|
+
},
|
|
257
|
+
{
|
|
258
|
+
name: "Self-Consistency",
|
|
259
|
+
description: "Generate 3 short reasoning drafts in parallel, return most consistent answer",
|
|
260
|
+
evaluator: (input, mode) => evaluateSelfConsistency(input, mode)
|
|
261
|
+
},
|
|
262
|
+
{
|
|
263
|
+
name: "PAL (Program-Aided Language)",
|
|
264
|
+
description: "Generate executable code for computational tasks",
|
|
265
|
+
evaluator: (input, mode) => evaluatePAL(input, mode)
|
|
266
|
+
},
|
|
267
|
+
{
|
|
268
|
+
name: "Reflexion",
|
|
269
|
+
description: "Single critique and revision cycle for confidence < 0.7",
|
|
270
|
+
evaluator: (input, mode) => evaluateReflexion(input, mode)
|
|
271
|
+
},
|
|
272
|
+
{
|
|
273
|
+
name: "ToT-lite (Tree of Thoughts)",
|
|
274
|
+
description: "Bounded breadth/depth exploration for complex problem decomposition",
|
|
275
|
+
evaluator: (input, mode) => evaluateToTLite(input, mode)
|
|
276
|
+
},
|
|
277
|
+
{
|
|
278
|
+
name: "Progressive-Hint Prompting (PHP)",
|
|
279
|
+
description: "Use previously generated outputs as contextual hints",
|
|
280
|
+
evaluator: (input, mode) => evaluatePHP(input, mode)
|
|
281
|
+
},
|
|
282
|
+
{
|
|
283
|
+
name: "Cache-Augmented Generation (CAG)",
|
|
284
|
+
description: "Preload all relevant context into working memory",
|
|
285
|
+
evaluator: (input, mode) => evaluateCAG(input, mode)
|
|
286
|
+
},
|
|
287
|
+
{
|
|
288
|
+
name: "Cognitive Scaffolding Prompting",
|
|
289
|
+
description: "Structure reasoning through metacognitive frameworks",
|
|
290
|
+
evaluator: (input, mode) => evaluateCognitiveScaffolding(input, mode)
|
|
291
|
+
},
|
|
292
|
+
{
|
|
293
|
+
name: "Internal Knowledge Synthesis (IKS)",
|
|
294
|
+
description: "Generate hypothetical knowledge constructs from parametric memory",
|
|
295
|
+
evaluator: (input, mode) => evaluateIKS(input, mode)
|
|
296
|
+
},
|
|
297
|
+
{
|
|
298
|
+
name: "Knowledge Synthesis Prompting (KSP)",
|
|
299
|
+
description: "Integrate knowledge from multiple internal domains",
|
|
300
|
+
evaluator: (input, mode) => evaluateKSP(input, mode)
|
|
301
|
+
}
|
|
302
|
+
];
|
|
303
|
+
// Run parallel evaluation of all strategies
|
|
304
|
+
return strategies.map(strategy => {
|
|
305
|
+
const evaluation = strategy.evaluator(input, mode);
|
|
306
|
+
return {
|
|
307
|
+
name: strategy.name,
|
|
308
|
+
description: strategy.description,
|
|
309
|
+
solutionLevel: evaluation.solutionLevel,
|
|
310
|
+
efficiencyLevel: evaluation.efficiencyLevel,
|
|
311
|
+
totalScore: evaluation.solutionLevel + evaluation.efficiencyLevel,
|
|
312
|
+
rationale: evaluation.rationale
|
|
313
|
+
};
|
|
314
|
+
}).sort((a, b) => b.totalScore - a.totalScore); // Sort by highest total score
|
|
315
|
+
}
|
|
316
|
+
/**
|
|
317
|
+
* Formats strategy evaluations for display
|
|
318
|
+
*/
|
|
319
|
+
function formatStrategyEvaluations(evaluations) {
|
|
320
|
+
return evaluations.map((evaluation, index) => `**${index + 1}. ${evaluation.name}**
|
|
321
|
+
- Solution Level: ${evaluation.solutionLevel.toFixed(2)}
|
|
322
|
+
- Efficiency Level: ${evaluation.efficiencyLevel.toFixed(2)}
|
|
323
|
+
- **Total Score: ${evaluation.totalScore.toFixed(2)}**
|
|
324
|
+
- Rationale: ${evaluation.rationale}`).join('\n\n');
|
|
325
|
+
}
|
|
326
|
+
/**
|
|
327
|
+
* Selects the optimal strategy based on highest combined score
|
|
328
|
+
* If multiple strategies score 1.71+, combines them for hybrid approach
|
|
329
|
+
*/
|
|
330
|
+
function selectOptimalStrategy(evaluations) {
|
|
331
|
+
const highScoreStrategies = evaluations.filter(evaluation => evaluation.totalScore >= 1.71);
|
|
332
|
+
if (highScoreStrategies.length > 1) {
|
|
333
|
+
// COMBINATION STRATEGY: Multiple high-scoring strategies
|
|
334
|
+
const combinedNames = highScoreStrategies.map(s => s.name).join(' + ');
|
|
335
|
+
const avgScore = highScoreStrategies.reduce((sum, s) => sum + s.totalScore, 0) / highScoreStrategies.length;
|
|
336
|
+
const combinedEfficiency = Math.max(...highScoreStrategies.map(s => s.efficiencyLevel));
|
|
337
|
+
return `**🔥 HYBRID COMBINATION STRATEGY: ${combinedNames}**
|
|
338
|
+
- Combined Strategies: ${highScoreStrategies.length} high-scoring approaches (≥1.71)
|
|
339
|
+
- Average Total Score: ${avgScore.toFixed(2)}
|
|
340
|
+
- Parallel Solution Generation: Each strategy contributes unique cognitive perspective
|
|
341
|
+
- Hybrid Rationale: ${generateCombinationRationale(highScoreStrategies)}
|
|
342
|
+
- Recommendation: Use ${Math.ceil(combinedEfficiency * 12)} external tools before returning to deliberate MCP
|
|
343
|
+
|
|
344
|
+
**🧠 PARALLEL COGNITIVE FUSION:**
|
|
345
|
+
${highScoreStrategies.map((strategy, i) => ` ${i + 1}. ${strategy.name} (${strategy.totalScore.toFixed(2)}) - ${strategy.rationale}`).join('\n')}`;
|
|
346
|
+
}
|
|
347
|
+
else {
|
|
348
|
+
// SINGLE STRATEGY: Highest scoring approach
|
|
349
|
+
const optimal = evaluations[0];
|
|
350
|
+
return `**${optimal.name}** (Total Score: ${optimal.totalScore.toFixed(2)})
|
|
351
|
+
- Selected for: ${optimal.rationale}
|
|
352
|
+
- Recommendation: Use ${Math.ceil(optimal.efficiencyLevel * 10)} external tools before returning to deliberate MCP`;
|
|
353
|
+
}
|
|
354
|
+
}
|
|
355
|
+
/**
|
|
356
|
+
* Generates rationale for combination strategy approach
|
|
357
|
+
*/
|
|
358
|
+
function generateCombinationRationale(strategies) {
|
|
359
|
+
const strengths = strategies.map(s => s.name.split(' ')[0]).join(', ');
|
|
360
|
+
return `Synergistic combination leveraging ${strengths} methodologies for enhanced cognitive processing with parallel solution generation and cross-validation`;
|
|
361
|
+
}
|
|
362
|
+
/**
|
|
363
|
+
* PARALLEL SOLUTION GENERATION: Creates unique solutions for each high-scoring strategy
|
|
364
|
+
* Each strategy contributes its cognitive perspective for hybrid cognitive fusion
|
|
365
|
+
*/
|
|
366
|
+
function generateParallelSolutions(input, mode, strategies, stage1Context) {
|
|
367
|
+
const solutionsByStrategy = strategies.map((strategy, index) => {
|
|
368
|
+
const solutionApproach = generateStrategySolution(input, mode, strategy, stage1Context);
|
|
369
|
+
return `**Solution ${index + 1} - ${strategy.name} Approach:**
|
|
370
|
+
- Cognitive Focus: ${strategy.description}
|
|
371
|
+
- Solution Score: ${strategy.solutionLevel.toFixed(2)} | Efficiency: ${strategy.efficiencyLevel.toFixed(2)}
|
|
372
|
+
- Strategic Solution: ${solutionApproach.solution}
|
|
373
|
+
- Implementation Notes: ${solutionApproach.implementation}
|
|
374
|
+
- Validation Method: ${solutionApproach.validation}`;
|
|
375
|
+
});
|
|
376
|
+
const fusionSynthesis = generateFusionSynthesis(strategies, input, mode);
|
|
377
|
+
return `${solutionsByStrategy.join('\n\n')}
|
|
378
|
+
|
|
379
|
+
**🌟 COGNITIVE FUSION SYNTHESIS:**
|
|
380
|
+
${fusionSynthesis}
|
|
381
|
+
|
|
382
|
+
**🚀 HYBRID IMPLEMENTATION ROADMAP:**
|
|
383
|
+
${generateHybridImplementation(strategies, mode)}`;
|
|
384
|
+
}
|
|
385
|
+
/**
|
|
386
|
+
* Generates a strategy-specific solution approach
|
|
387
|
+
*/
|
|
388
|
+
function generateStrategySolution(input, mode, strategy, context) {
|
|
389
|
+
// Strategy-specific solution generation based on cognitive approach
|
|
390
|
+
switch (strategy.name) {
|
|
391
|
+
case "Cache-Augmented Reasoning + ReAct":
|
|
392
|
+
return {
|
|
393
|
+
solution: `Iterative reasoning cycles with cached knowledge integration for ${mode} optimization`,
|
|
394
|
+
implementation: `Stage-wise knowledge activation → reasoning → action planning → validation loop`,
|
|
395
|
+
validation: `Multi-cycle consistency checking with knowledge coherence verification`
|
|
396
|
+
};
|
|
397
|
+
case "Self-Consistency":
|
|
398
|
+
return {
|
|
399
|
+
solution: `Triple-path parallel reasoning with consensus validation for robust ${mode} outcomes`,
|
|
400
|
+
implementation: `Generate 3 independent solution paths → cross-validate → select consensus approach`,
|
|
401
|
+
validation: `Inter-path consistency analysis with confidence scoring`
|
|
402
|
+
};
|
|
403
|
+
case "ToT-lite (Tree of Thoughts)":
|
|
404
|
+
return {
|
|
405
|
+
solution: `Bounded tree exploration with systematic branch evaluation for comprehensive ${mode}`,
|
|
406
|
+
implementation: `Problem decomposition → parallel branch generation → optimal path selection`,
|
|
407
|
+
validation: `Branch quality assessment with feasibility scoring`
|
|
408
|
+
};
|
|
409
|
+
case "Cognitive Scaffolding Prompting":
|
|
410
|
+
return {
|
|
411
|
+
solution: `Metacognitive framework structuring for systematic ${mode} enhancement`,
|
|
412
|
+
implementation: `Cognitive model construction → scaffolding application → progressive refinement`,
|
|
413
|
+
validation: `Metacognitive consistency checking with framework adherence`
|
|
414
|
+
};
|
|
415
|
+
default:
|
|
416
|
+
return {
|
|
417
|
+
solution: `Strategy-optimized approach tailored for ${mode} requirements with ${strategy.name} methodology`,
|
|
418
|
+
implementation: `Systematic application of ${strategy.name} principles with ${mode}-specific adaptations`,
|
|
419
|
+
validation: `Strategy-aligned validation with cognitive coherence assessment`
|
|
420
|
+
};
|
|
421
|
+
}
|
|
422
|
+
}
|
|
423
|
+
/**
|
|
424
|
+
* Creates fusion synthesis combining multiple cognitive approaches
|
|
425
|
+
*/
|
|
426
|
+
function generateFusionSynthesis(strategies, input, mode) {
|
|
427
|
+
const cognitiveStrengths = strategies.map(s => s.name.split(' ')[0]).join(' + ');
|
|
428
|
+
const avgSolutionLevel = (strategies.reduce((sum, s) => sum + s.solutionLevel, 0) / strategies.length).toFixed(2);
|
|
429
|
+
const avgEfficiencyLevel = (strategies.reduce((sum, s) => sum + s.efficiencyLevel, 0) / strategies.length).toFixed(2);
|
|
430
|
+
return `Cognitive fusion leveraging ${cognitiveStrengths} approaches creates synergistic ${mode} solution with enhanced reliability (Avg Solution: ${avgSolutionLevel}, Avg Efficiency: ${avgEfficiencyLevel}). Each strategy contributes unique cognitive perspective while cross-validation ensures coherence and optimization.`;
|
|
431
|
+
}
|
|
432
|
+
/**
|
|
433
|
+
* Generates hybrid implementation roadmap for combined strategies
|
|
434
|
+
*/
|
|
435
|
+
function generateHybridImplementation(strategies, mode) {
|
|
436
|
+
const priorityOrder = strategies.sort((a, b) => b.solutionLevel - a.solutionLevel);
|
|
437
|
+
const roadmap = priorityOrder.map((strategy, index) => `${index + 1}. Apply ${strategy.name} methodology (${strategy.totalScore.toFixed(2)} priority score)`).join('\n');
|
|
438
|
+
return `Sequential-parallel implementation for optimal ${mode} outcomes:
|
|
439
|
+
${roadmap}
|
|
440
|
+
|
|
441
|
+
Cross-validation checkpoints after each strategy application ensure cognitive coherence and progressive refinement.`;
|
|
442
|
+
}
|
|
443
|
+
// Strategy-specific evaluation functions
|
|
444
|
+
function evaluateCacheAugmentedReact(input, mode) {
|
|
445
|
+
const complexity = analyzeComplexity(input);
|
|
446
|
+
const needsExternalData = requiresExternalData(input);
|
|
447
|
+
return {
|
|
448
|
+
solutionLevel: needsExternalData ? 0.85 : 0.70,
|
|
449
|
+
efficiencyLevel: complexity > 0.7 ? 0.90 : 0.75,
|
|
450
|
+
rationale: `Optimal for ${complexity > 0.7 ? 'complex' : 'moderate'} tasks ${needsExternalData ? 'requiring external data integration' : 'with internal knowledge sufficiency'}`
|
|
451
|
+
};
|
|
452
|
+
}
|
|
453
|
+
function evaluateSelfConsistency(input, mode) {
|
|
454
|
+
const isAmbiguous = containsAmbiguity(input);
|
|
455
|
+
const isHighStakes = isHighStakesDecision(input);
|
|
456
|
+
return {
|
|
457
|
+
solutionLevel: isAmbiguous || isHighStakes ? 0.88 : 0.60,
|
|
458
|
+
efficiencyLevel: isAmbiguous ? 0.65 : 0.80,
|
|
459
|
+
rationale: `Best for ${isAmbiguous ? 'ambiguous' : 'clear'} ${isHighStakes ? 'high-stakes' : 'standard'} decisions`
|
|
460
|
+
};
|
|
461
|
+
}
|
|
462
|
+
function evaluatePAL(input, mode) {
|
|
463
|
+
const isComputational = requiresComputation(input);
|
|
464
|
+
const hasMathematicalElements = containsMathematical(input);
|
|
465
|
+
return {
|
|
466
|
+
solutionLevel: isComputational ? 0.95 : 0.30,
|
|
467
|
+
efficiencyLevel: isComputational ? 0.88 : 0.20,
|
|
468
|
+
rationale: `${isComputational ? 'Excellent' : 'Poor'} fit for ${hasMathematicalElements ? 'mathematical' : 'non-mathematical'} problem types`
|
|
469
|
+
};
|
|
470
|
+
}
|
|
471
|
+
function evaluateReflexion(input, mode) {
|
|
472
|
+
const needsRefinement = requiresRefinement(input);
|
|
473
|
+
const complexity = analyzeComplexity(input);
|
|
474
|
+
return {
|
|
475
|
+
solutionLevel: needsRefinement ? 0.80 : 0.55,
|
|
476
|
+
efficiencyLevel: complexity < 0.7 ? 0.75 : 0.60,
|
|
477
|
+
rationale: `Suitable for ${needsRefinement ? 'iterative refinement' : 'single-pass'} tasks with ${complexity < 0.7 ? 'moderate' : 'high'} complexity`
|
|
478
|
+
};
|
|
479
|
+
}
|
|
480
|
+
function evaluateToTLite(input, mode) {
|
|
481
|
+
const needsDecomposition = requiresDecomposition(input);
|
|
482
|
+
const hasMultiplePaths = hasAlternativeSolutions(input);
|
|
483
|
+
return {
|
|
484
|
+
solutionLevel: needsDecomposition ? 0.92 : 0.45,
|
|
485
|
+
efficiencyLevel: hasMultiplePaths ? 0.70 : 0.85,
|
|
486
|
+
rationale: `${needsDecomposition ? 'Excellent' : 'Moderate'} for problems ${hasMultiplePaths ? 'with multiple solution paths' : 'with clear singular approach'}`
|
|
487
|
+
};
|
|
488
|
+
}
|
|
489
|
+
function evaluatePHP(input, mode) {
|
|
490
|
+
const isIterative = requiresIterativeApproach(input);
|
|
491
|
+
const benefitsFromHints = canBenefitFromHints(input);
|
|
492
|
+
return {
|
|
493
|
+
solutionLevel: isIterative && benefitsFromHints ? 0.78 : 0.50,
|
|
494
|
+
efficiencyLevel: isIterative ? 0.82 : 0.65,
|
|
495
|
+
rationale: `${isIterative ? 'Strong' : 'Weak'} match for ${benefitsFromHints ? 'hint-guided' : 'direct'} problem solving`
|
|
496
|
+
};
|
|
497
|
+
}
|
|
498
|
+
function evaluateCAG(input, mode) {
|
|
499
|
+
const needsContext = requiresExtensiveContext(input);
|
|
500
|
+
const hasLatencyConstraints = hasPerformanceConstraints(input);
|
|
501
|
+
return {
|
|
502
|
+
solutionLevel: needsContext ? 0.86 : 0.60,
|
|
503
|
+
efficiencyLevel: hasLatencyConstraints ? 0.90 : 0.75,
|
|
504
|
+
rationale: `${needsContext ? 'Ideal' : 'Average'} for context-heavy tasks with ${hasLatencyConstraints ? 'strict' : 'flexible'} performance requirements`
|
|
505
|
+
};
|
|
506
|
+
}
|
|
507
|
+
function evaluateCognitiveScaffolding(input, mode) {
|
|
508
|
+
const needsMetacognition = requiresMetacognition(input);
|
|
509
|
+
const isComplexReasoning = requiresComplexReasoning(input);
|
|
510
|
+
return {
|
|
511
|
+
solutionLevel: needsMetacognition ? 0.83 : 0.55,
|
|
512
|
+
efficiencyLevel: isComplexReasoning ? 0.77 : 0.85,
|
|
513
|
+
rationale: `${needsMetacognition ? 'Well-suited' : 'Poorly-suited'} for ${isComplexReasoning ? 'complex reasoning' : 'simple reasoning'} tasks`
|
|
514
|
+
};
|
|
515
|
+
}
|
|
516
|
+
function evaluateIKS(input, mode) {
|
|
517
|
+
const needsNovelConcepts = requiresNovelConceptGeneration(input);
|
|
518
|
+
const canUseParametricKnowledge = canLeverageParametricKnowledge(input);
|
|
519
|
+
return {
|
|
520
|
+
solutionLevel: needsNovelConcepts ? 0.81 : 0.45,
|
|
521
|
+
efficiencyLevel: canUseParametricKnowledge ? 0.88 : 0.60,
|
|
522
|
+
rationale: `${needsNovelConcepts ? 'Strong' : 'Weak'} fit for ${canUseParametricKnowledge ? 'knowledge-synthesizable' : 'knowledge-limited'} problems`
|
|
523
|
+
};
|
|
524
|
+
}
|
|
525
|
+
function evaluateKSP(input, mode) {
|
|
526
|
+
const needsCrossDomainKnowledge = requiresCrossDomainIntegration(input);
|
|
527
|
+
const isFactuallyIntensive = isFactuallyComplex(input);
|
|
528
|
+
return {
|
|
529
|
+
solutionLevel: needsCrossDomainKnowledge ? 0.89 : 0.50,
|
|
530
|
+
efficiencyLevel: isFactuallyIntensive ? 0.75 : 0.85,
|
|
531
|
+
rationale: `${needsCrossDomainKnowledge ? 'Optimal' : 'Suboptimal'} for ${isFactuallyIntensive ? 'fact-intensive' : 'conceptual'} cross-domain tasks`
|
|
532
|
+
};
|
|
533
|
+
}
|
|
534
|
+
// Analysis helper functions
|
|
535
|
+
function analyzeComplexity(input) {
|
|
536
|
+
const complexityIndicators = [
|
|
537
|
+
/multiple.*step/gi, /complex.*problem/gi, /various.*factor/gi,
|
|
538
|
+
/interdependent/gi, /system.*level/gi, /comprehensive/gi
|
|
539
|
+
];
|
|
540
|
+
const matches = complexityIndicators.reduce((count, pattern) => count + (input.match(pattern)?.length || 0), 0);
|
|
541
|
+
return Math.min(matches * 0.15, 0.95);
|
|
542
|
+
}
|
|
543
|
+
function requiresExternalData(input) {
|
|
544
|
+
return /current.*data|latest.*information|real.*time|up.*to.*date|search|web/gi.test(input);
|
|
545
|
+
}
|
|
546
|
+
function containsAmbiguity(input) {
|
|
547
|
+
return /maybe|might|could|uncertain|unclear|ambiguous|multiple.*interpretation/gi.test(input);
|
|
548
|
+
}
|
|
549
|
+
function isHighStakesDecision(input) {
|
|
550
|
+
return /critical|important|urgent|decision|choose|select.*best|recommendation/gi.test(input);
|
|
551
|
+
}
|
|
552
|
+
function requiresComputation(input) {
|
|
553
|
+
return /calculate|compute|algorithm|mathematical|numeric|formula|equation/gi.test(input);
|
|
554
|
+
}
|
|
555
|
+
function containsMathematical(input) {
|
|
556
|
+
return /\d+|math|equation|formula|calculate|number|statistic|metric/gi.test(input);
|
|
557
|
+
}
|
|
558
|
+
function requiresRefinement(input) {
|
|
559
|
+
return /improve|refine|enhance|optimize|iterate|revise|better/gi.test(input);
|
|
560
|
+
}
|
|
561
|
+
function requiresDecomposition(input) {
|
|
562
|
+
return /complex.*system|break.*down|decompose|multiple.*part|component|modular/gi.test(input);
|
|
563
|
+
}
|
|
564
|
+
function hasAlternativeSolutions(input) {
|
|
565
|
+
return /alternative|option|multiple.*way|different.*approach|various.*method/gi.test(input);
|
|
566
|
+
}
|
|
567
|
+
function requiresIterativeApproach(input) {
|
|
568
|
+
return /step.*by.*step|iterative|gradual|progressive|build.*upon/gi.test(input);
|
|
569
|
+
}
|
|
570
|
+
function canBenefitFromHints(input) {
|
|
571
|
+
return /guide|hint|clue|suggestion|direction|lead.*to/gi.test(input);
|
|
572
|
+
}
|
|
573
|
+
function requiresExtensiveContext(input) {
|
|
574
|
+
return /context|background|comprehensive|detailed|extensive|full.*picture/gi.test(input);
|
|
575
|
+
}
|
|
576
|
+
function hasPerformanceConstraints(input) {
|
|
577
|
+
return /fast|quick|rapid|immediate|urgent|time.*sensitive|performance/gi.test(input);
|
|
578
|
+
}
|
|
579
|
+
function requiresMetacognition(input) {
|
|
580
|
+
return /think.*about.*thinking|meta|reasoning.*process|cognitive|mental.*model/gi.test(input);
|
|
581
|
+
}
|
|
582
|
+
function requiresComplexReasoning(input) {
|
|
583
|
+
return /complex.*reasoning|sophisticated|advanced.*logic|deep.*analysis/gi.test(input);
|
|
584
|
+
}
|
|
585
|
+
function requiresNovelConceptGeneration(input) {
|
|
586
|
+
return /novel|creative|innovative|generate.*idea|new.*concept|original/gi.test(input);
|
|
587
|
+
}
|
|
588
|
+
function canLeverageParametricKnowledge(input) {
|
|
589
|
+
return /knowledge|fact|information|data|learn|known|understand/gi.test(input);
|
|
590
|
+
}
|
|
591
|
+
function requiresCrossDomainIntegration(input) {
|
|
592
|
+
return /interdisciplinary|cross.*domain|multiple.*field|integrate.*knowledge/gi.test(input);
|
|
593
|
+
}
|
|
594
|
+
function isFactuallyComplex(input) {
|
|
595
|
+
return /fact|data|information|evidence|research|study|report|statistics/gi.test(input);
|
|
596
|
+
}
|
|
119
597
|
// --- 6-Stage Cognitive Processing Functions with Integrated Prompting Strategies ---
|
|
120
598
|
/**
|
|
121
599
|
* STAGE 1: SCIENTIFIC INVESTIGATION
|
|
@@ -347,8 +825,27 @@ function generateMultipleObservationPaths(input, mode, context) {
|
|
|
347
825
|
return paths.join('\n');
|
|
348
826
|
}
|
|
349
827
|
function generateOrientationAlternatives(input, mode, stage1Result) {
|
|
828
|
+
// ENHANCED: Parallel Prompting Strategy Evaluation for Orient Stage
|
|
829
|
+
const strategyEvaluations = evaluatePromptingStrategiesInParallel(input, mode, stage1Result);
|
|
350
830
|
const alternatives = generateSolutionAlternatives(input, mode, stage1Result);
|
|
351
|
-
|
|
831
|
+
const alternativesList = alternatives.map((alt, i) => `**Alternative ${i + 1}:** ${alt.description} (Feasibility: ${alt.feasibility})`).join('\n');
|
|
832
|
+
// Check for combination strategy requirement (1.71+ threshold)
|
|
833
|
+
const highScoreStrategies = strategyEvaluations.filter(evaluation => evaluation.totalScore >= 1.71);
|
|
834
|
+
let combinedSolutions = '';
|
|
835
|
+
if (highScoreStrategies.length > 1) {
|
|
836
|
+
// PARALLEL SOLUTION GENERATION: Multiple high-scoring strategies
|
|
837
|
+
combinedSolutions = `
|
|
838
|
+
|
|
839
|
+
**🔥 PARALLEL COGNITIVE FUSION - SOLUTION GENERATION:**
|
|
840
|
+
${generateParallelSolutions(input, mode, highScoreStrategies, stage1Result)}`;
|
|
841
|
+
}
|
|
842
|
+
return `${alternativesList}
|
|
843
|
+
|
|
844
|
+
**🧠 PARALLEL PROMPTING STRATEGY EVALUATION:**
|
|
845
|
+
${formatStrategyEvaluations(strategyEvaluations)}
|
|
846
|
+
|
|
847
|
+
**🎯 SELECTED OPTIMAL STRATEGY:**
|
|
848
|
+
${selectOptimalStrategy(strategyEvaluations)}${combinedSolutions}`;
|
|
352
849
|
}
|
|
353
850
|
function generateReasoningBranches(input, mode, context) {
|
|
354
851
|
return `**Branch A (Deductive):** ${performDeductiveReasoning(input, mode)}
|
|
@@ -844,23 +1341,35 @@ function assessMethodologicalRigor(stage1Result) {
|
|
|
844
1341
|
server.tool("deliberate", {
|
|
845
1342
|
input: z
|
|
846
1343
|
.string()
|
|
847
|
-
.describe("REQUIRED:
|
|
1344
|
+
.describe("REQUIRED: The problem, question, decision, or situation requiring cognitive deliberation"),
|
|
848
1345
|
mode: z
|
|
849
1346
|
.enum(["analyze", "decide", "synthesize", "evaluate"])
|
|
850
1347
|
.default("analyze")
|
|
851
|
-
.describe("
|
|
1348
|
+
.describe("Cognitive processing mode: 'analyze' for breakdown, 'decide' for decision making, 'synthesize' for integration, 'evaluate' for assessment"),
|
|
852
1349
|
context: z
|
|
853
1350
|
.string()
|
|
854
1351
|
.optional()
|
|
855
|
-
.describe("
|
|
856
|
-
|
|
1352
|
+
.describe("Optional additional context, constraints, or background information"),
|
|
1353
|
+
stage: z
|
|
1354
|
+
.enum(["stage1", "stage2", "stage3", "stage4", "stage5", "stage6"])
|
|
1355
|
+
.default("stage1")
|
|
1356
|
+
.describe("REQUIRED: Current stage in mandatory 6-stage cognitive progression. Must start with stage1 and progress sequentially through all stages for complete cognitive enhancement."),
|
|
1357
|
+
previous_results: z
|
|
1358
|
+
.string()
|
|
1359
|
+
.optional()
|
|
1360
|
+
.describe("REQUIRED for stages 2-6: Accumulated results from all previous stages. Essential for cognitive continuity and progressive enhancement.")
|
|
1361
|
+
}, async ({ input, mode, context, stage, previous_results }) => {
|
|
857
1362
|
const toolName = 'deliberate';
|
|
858
|
-
logToolCall(toolName, `Mode: ${mode},
|
|
1363
|
+
logToolCall(toolName, `Mode: ${mode}, Stage: ${stage}, Previous: ${previous_results ? 'Yes' : 'No'}`);
|
|
859
1364
|
try {
|
|
860
|
-
//
|
|
861
|
-
|
|
862
|
-
|
|
863
|
-
|
|
1365
|
+
// Validate required previous results for stages 2-6
|
|
1366
|
+
if (stage !== "stage1" && !previous_results) {
|
|
1367
|
+
throw new Error(`Stage ${stage} requires previous_results parameter. Cognitive enhancement requires sequential progression through all stages.`);
|
|
1368
|
+
}
|
|
1369
|
+
// Process the current stage with progressive cognitive enhancement
|
|
1370
|
+
const stageResult = await processProgressiveStage(input, mode, context, stage, previous_results);
|
|
1371
|
+
logToolResult(toolName, true, `Stage ${stage} completed - Continue to next stage for full cognitive enhancement`);
|
|
1372
|
+
return { content: [{ type: "text", text: stageResult }] };
|
|
864
1373
|
}
|
|
865
1374
|
catch (error) {
|
|
866
1375
|
return logToolError(toolName, error);
|
package/package.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@nbiish/cognitive-tools-mcp",
|
|
3
|
-
"version": "
|
|
4
|
-
"description": "Revolutionary MCP server with Enhanced 6-Stage Cognitive
|
|
3
|
+
"version": "8.3.2",
|
|
4
|
+
"description": "Revolutionary MCP server with Enhanced 6-Stage Mandatory Cognitive Progression Framework requiring sequential processing through all stages for complete cognitive enhancement. Scientific Investigation + OOReD + Critical Thinking with 10 expertly integrated prompting strategies and intelligent tool usage tracking.",
|
|
5
5
|
"private": false,
|
|
6
6
|
"type": "module",
|
|
7
7
|
"bin": {
|