smart-thinking-mcp
Version:
Un serveur MCP avancé pour le raisonnement multi-dimensionnel, adaptatif et collaboratif
141 lines • 6.58 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
const reasoning_orchestrator_1 = require("../reasoning-orchestrator");
const similarity_engine_1 = require("../similarity-engine");
const quality_evaluator_1 = require("../quality-evaluator");
const tool_integrator_1 = require("../tool-integrator");
const metrics_calculator_1 = require("../metrics-calculator");
const visualizer_1 = require("../visualizer");
const memory_manager_1 = require("../memory-manager");
const service_container_1 = require("../services/service-container");
const verification_memory_1 = require("../verification-memory");
function createOrchestrator() {
const similarityEngine = new similarity_engine_1.SimilarityEngine();
const metricsCalculator = new metrics_calculator_1.MetricsCalculator();
const qualityEvaluator = new quality_evaluator_1.QualityEvaluator();
const toolIntegrator = new tool_integrator_1.ToolIntegrator();
const visualizer = new visualizer_1.Visualizer();
const memoryManager = new memory_manager_1.MemoryManager(similarityEngine);
const serviceContainer = service_container_1.ServiceContainer.getInstance();
serviceContainer.initializeServices(toolIntegrator, metricsCalculator, similarityEngine);
const verificationService = serviceContainer.getVerificationService();
const verificationMemory = verification_memory_1.VerificationMemory.getInstance();
verificationMemory.setSimilarityEngine(similarityEngine);
qualityEvaluator.setVerificationService(verificationService);
return new reasoning_orchestrator_1.ReasoningOrchestrator({
similarityEngine,
qualityEvaluator,
verificationService,
toolIntegrator,
metricsCalculator,
visualizer,
memoryManager
});
}
function formatPercent(value) {
return `${Math.round(value * 100)}%`;
}
function printTimeline(response) {
const timeline = response.reasoningTimeline || [];
console.log(' Timeline:');
for (const step of timeline) {
console.log(` [${step.status}] ${step.label} — ${step.timestamp}`);
}
}
function printHeuristicSummary(trace) {
if (!trace) {
return;
}
const evaluationStep = trace.find(step => step.kind === 'evaluation' && step.status === 'completed');
if (!evaluationStep) {
return;
}
const details = evaluationStep.details;
if (!details) {
return;
}
const { confidence, relevance, quality } = details;
if (typeof confidence === 'number' && typeof relevance === 'number' && typeof quality === 'number') {
console.log(` Heuristics → confidence ${formatPercent(confidence)}, relevance ${formatPercent(relevance)}, quality ${formatPercent(quality)}`);
}
}
async function runDemo() {
const orchestrator = createOrchestrator();
const sessionId = `demo-session-${Date.now()}`;
const context = {
sessionId,
previousThoughtIds: []
};
const steps = [
{
title: 'Baseline observation',
description: 'Capture an initial fact without triggering deep verification.',
buildParams: ({ sessionId: sid }) => ({
sessionId: sid,
thought: 'The Eiffel Tower stands 324 meters tall and uses two separate elevator systems.',
thoughtType: 'regular'
})
},
{
title: 'Cross-check calculation',
description: 'Add a calculation-oriented thought and request explicit verification.',
buildParams: ({ sessionId: sid, previousThoughtIds }) => ({
sessionId: sid,
thought: 'Maintenance reports indicate that repainting 250,000 square meters with 60 tons of paint every seven years prevents corrosion.',
thoughtType: 'hypothesis',
containsCalculations: true,
requestVerification: true,
connections: previousThoughtIds.slice(-1).map(id => ({
targetId: id,
type: 'supports',
strength: 0.8
}))
})
},
{
title: 'Synthesis and next steps',
description: 'Produce a follow-up reasoning step connected to previous context.',
buildParams: ({ sessionId: sid, previousThoughtIds }) => ({
sessionId: sid,
thought: 'Given the maintenance cadence, evaluating humidity forecasts could optimise the next repaint window.',
thoughtType: 'conclusion',
requestSuggestions: true,
suggestTools: true,
connections: previousThoughtIds.map(id => ({
targetId: id,
type: 'synthesizes',
strength: 0.7
}))
})
}
];
console.log('Smart-Thinking progressive reasoning demo');
console.log(`Session: ${sessionId}`);
console.log('----------------------------------------');
for (const step of steps) {
const params = step.buildParams(context);
const { response, thoughtGraph } = await orchestrator.run(params);
console.log(`\nStep: ${step.title}`);
console.log(`Description: ${step.description}`);
console.log(`Thought ID: ${response.thoughtId}`);
console.log(`Metrics → confidence ${formatPercent(response.qualityMetrics.confidence)}, relevance ${formatPercent(response.qualityMetrics.relevance)}, quality ${formatPercent(response.qualityMetrics.quality)}`);
if (response.verificationStatus) {
console.log(`Verification status: ${response.verificationStatus}`);
}
if (typeof response.reliabilityScore === 'number') {
console.log(`Reliability score: ${formatPercent(response.reliabilityScore)}`);
}
printHeuristicSummary(response.reasoningTrace);
printTimeline(response);
const sessionThoughts = thoughtGraph.getAllThoughts(context.sessionId);
const connectionCount = sessionThoughts.reduce((total, node) => total + node.connections.length, 0);
console.log(` Graph snapshot → ${sessionThoughts.length} thoughts, ${connectionCount} connections.`);
context.previousThoughtIds.push(response.thoughtId);
}
console.log('\nDemo complete. Inspect persisted data or run the MCP server to continue the session.');
}
runDemo().catch(error => {
console.error('Demo failed:', error);
process.exit(1);
});
//# sourceMappingURL=demo-session.js.map