MCP Reasoner
by parmarjh
- mcp-reasoner
- src
- strategies
import { ThoughtNode, ReasoningRequest, ReasoningResponse } from '../types.js';
import { StateManager } from '../state.js';
export interface StrategyMetrics {
name: string;
nodesExplored: number;
averageScore: number;
maxDepth: number;
active?: boolean;
[key: string]: number | string | boolean | undefined; // Allow additional strategy-specific metrics including booleans
}
export abstract class BaseStrategy {
protected stateManager: StateManager;
constructor(stateManager: StateManager) {
this.stateManager = stateManager;
}
abstract processThought(request: ReasoningRequest): Promise<ReasoningResponse>;
protected async getNode(id: string): Promise<ThoughtNode | undefined> {
return this.stateManager.getNode(id);
}
protected async saveNode(node: ThoughtNode): Promise<void> {
return this.stateManager.saveNode(node);
}
protected evaluateThought(node: ThoughtNode, parent?: ThoughtNode): number {
// Base evaluation logic
const logicalScore = this.calculateLogicalScore(node, parent);
const depthPenalty = this.calculateDepthPenalty(node);
const completionBonus = node.isComplete ? 0.2 : 0;
return (logicalScore + depthPenalty + completionBonus) / 3;
}
private calculateLogicalScore(node: ThoughtNode, parent?: ThoughtNode): number {
let score = 0;
// Length and complexity
score += Math.min(node.thought.length / 200, 0.3);
// Logical connectors
if (/\b(therefore|because|if|then|thus|hence|so)\b/i.test(node.thought)) {
score += 0.2;
}
// Mathematical/logical expressions
if (/[+\-*/=<>]/.test(node.thought)) {
score += 0.2;
}
// Parent-child coherence
if (parent) {
const coherence = this.calculateCoherence(parent.thought, node.thought);
score += coherence * 0.3;
}
return score;
}
private calculateDepthPenalty(node: ThoughtNode): number {
return Math.max(0, 1 - (node.depth / 10) * 0.3);
}
private calculateCoherence(parentThought: string, childThought: string): number {
// Simple coherence based on shared terms
const parentTerms = new Set(parentThought.toLowerCase().split(/\W+/));
const childTerms = childThought.toLowerCase().split(/\W+/);
const sharedTerms = childTerms.filter(term => parentTerms.has(term)).length;
return Math.min(sharedTerms / childTerms.length, 1);
}
// Required methods for all strategies
public async getBestPath(): Promise<ThoughtNode[]> {
const nodes = await this.stateManager.getAllNodes();
if (nodes.length === 0) return [];
// Default implementation - find highest scoring complete path
const completedNodes = nodes.filter(n => n.isComplete)
.sort((a, b) => b.score - a.score);
if (completedNodes.length === 0) return [];
return this.stateManager.getPath(completedNodes[0].id);
}
public async getMetrics(): Promise<StrategyMetrics> {
const nodes = await this.stateManager.getAllNodes();
return {
name: this.constructor.name,
nodesExplored: nodes.length,
averageScore: nodes.length > 0
? nodes.reduce((sum, n) => sum + n.score, 0) / nodes.length
: 0,
maxDepth: nodes.length > 0
? Math.max(...nodes.map(n => n.depth))
: 0
};
}
public async clear(): Promise<void> {
// Optional cleanup method for strategies
// Default implementation does nothing
}
}