Smart-Thinking

Implementation Reference

• src/reasoning-orchestrator.ts:116-338 (handler)

  Core orchestrator that executes the main logic of the smartthinking tool: manages reasoning steps, thought graph, evaluation, verification, memory, visualization, and returns structured response.
  public async run(params: SmartThinkingParams): Promise<{ response: SmartThinkingResponse; sessionId: string; thoughtGraph: ThoughtGraph }> { const tracker = new ReasoningStepTracker(); const sessionInitializationStep = tracker.start('context', 'Initialisation', 'Préparation de la session de raisonnement'); const sessionId = params.sessionId || uuidv4(); tracker.complete(sessionInitializationStep, { sessionId }); const thoughtGraph = new ThoughtGraph(sessionId, this.deps.similarityEngine, this.deps.qualityEvaluator); const loadStep = tracker.start('context', 'Chargement du graphe', 'Récupération de l’état précédent'); const previousState = await this.deps.memoryManager.loadGraphState(sessionId); if (previousState) { const imported = thoughtGraph.importEnrichedGraph(previousState); tracker.complete(loadStep, { imported, nodeCount: thoughtGraph.getAllThoughts(sessionId).length }); } else { tracker.complete(loadStep, { imported: false }); } const verificationStep = tracker.start('verification', 'Pré-vérification', 'Analyse initiale des calculs et garde-fous'); const preliminaryVerification = await this.deps.verificationService.performPreliminaryVerification( params.thought, !!params.containsCalculations ); tracker.complete(verificationStep, { detectedCalculations: preliminaryVerification.verifiedCalculations?.length || 0, initialVerification: preliminaryVerification.initialVerification }); const graphStep = tracker.start('graph', 'Insertion de la pensée', 'Ajout de la pensée dans le graphe'); const thoughtId = thoughtGraph.addThought( preliminaryVerification.preverifiedThought, params.thoughtType ?? 'regular', params.connections ?? [] ); tracker.complete(graphStep, { thoughtId, connectionCount: params.connections?.length ?? 0 }); const evaluationStep = tracker.start('evaluation', 'Évaluation heuristique', 'Calcul des métriques locales', [graphStep]); const metrics: ThoughtMetrics = await this.deps.qualityEvaluator.evaluate(thoughtId, thoughtGraph); thoughtGraph.updateThoughtMetrics(thoughtId, metrics); tracker.complete(evaluationStep, { confidence: metrics.confidence, relevance: metrics.relevance, quality: metrics.quality }); const heuristics = this.buildHeuristicTraces(thoughtId, metrics); const heuristicsJustification: ReasoningJustification = { summary: `Heuristiques calculées (confiance ${this.formatScore(metrics.confidence)}, pertinence ${this.formatScore(metrics.relevance)}, qualité ${this.formatScore(metrics.quality)})`, heuristics, timestamp: new Date().toISOString() }; tracker.addJustification(evaluationStep, heuristicsJustification); const currentThought = thoughtGraph.getThought(thoughtId); if (currentThought) { const existingJustifications = currentThought.reasoning?.justifications || []; currentThought.reasoning = { createdByStepId: evaluationStep, updatedAt: heuristicsJustification.timestamp, justifications: [...existingJustifications, heuristicsJustification], heuristicWeights: heuristics }; } this.decorateConnections(thoughtGraph, thoughtId, params.connections ?? [], heuristics, evaluationStep); const response: SmartThinkingResponse = { thoughtId, thought: preliminaryVerification.preverifiedThought, thoughtType: params.thoughtType ?? 'regular', qualityMetrics: metrics, sessionId, isVerified: preliminaryVerification.initialVerification, verificationStatus: preliminaryVerification.verificationInProgress ? 'verification_in_progress' : preliminaryVerification.initialVerification ? 'partially_verified' : 'unverified', certaintySummary: preliminaryVerification.verificationInProgress ? 'Vérification des calculs en cours...' : `Information ${preliminaryVerification.initialVerification ? 'partiellement vérifiée' : 'non vérifiée'}, niveau de confiance: ${Math.round(metrics.confidence * 100)}%.`, reliabilityScore: this.deps.metricsCalculator.calculateReliabilityScore( metrics, preliminaryVerification.initialVerification ? 'partially_verified' : 'unverified', preliminaryVerification.verifiedCalculations, undefined ) }; if (preliminaryVerification.verifiedCalculations?.length) { response.verification = { status: 'partially_verified', confidence: metrics.confidence, sources: ['Vérification interne des calculs'], verificationSteps: ['Annotation automatique des calculs détectés'], verifiedCalculations: preliminaryVerification.verifiedCalculations } as VerificationResult; response.isVerified = true; response.verificationStatus = 'partially_verified'; response.certaintySummary = `Calculs vérifiés automatiquement (${preliminaryVerification.verifiedCalculations.length}). Niveau de confiance: ${Math.round(metrics.confidence * 100)}%.`; } const previousVerificationStep = tracker.start('verification', 'Recherche de vérifications antérieures', 'Consultation de la mémoire de vérification', [evaluationStep]); const connectedIds = (params.connections ?? []).map(conn => conn.targetId); const previousVerification = await this.deps.verificationService.checkPreviousVerification( currentThought?.content || params.thought, sessionId, params.thoughtType ?? 'regular', connectedIds ); tracker.complete(previousVerificationStep, { previousMatch: !!previousVerification.previousVerification, similarity: previousVerification.previousVerification?.similarity }); if (previousVerification.previousVerification) { response.isVerified = previousVerification.isVerified; response.verificationStatus = previousVerification.verificationStatus; response.certaintySummary = previousVerification.certaintySummary; response.verification = previousVerification.verification; response.reliabilityScore = this.deps.metricsCalculator.calculateReliabilityScore( metrics, previousVerification.verificationStatus as VerificationStatus, preliminaryVerification.verifiedCalculations, response.reliabilityScore ); if (currentThought) { currentThought.metadata.previousVerification = { similarity: previousVerification.previousVerification.similarity, status: previousVerification.previousVerification.status, confidence: previousVerification.previousVerification.confidence, timestamp: previousVerification.previousVerification.timestamp }; } } const needsDeepVerification = (metrics.confidence < VerificationConfig.CONFIDENCE.VERIFICATION_REQUIRED || params.requestVerification) && !previousVerification.previousVerification; if (needsDeepVerification && currentThought) { const deepVerificationStep = tracker.start('verification', 'Vérification approfondie', 'Lancement d’une vérification complète', [previousVerificationStep]); try { const verification = await this.deps.verificationService.deepVerify( currentThought, params.containsCalculations ?? false, false, sessionId ); response.verification = verification; response.isVerified = ['verified', 'partially_verified'].includes(verification.status); response.verificationStatus = verification.status as VerificationDetailedStatus; response.reliabilityScore = this.deps.metricsCalculator.calculateReliabilityScore( metrics, verification.status as VerificationStatus, verification.verifiedCalculations, response.reliabilityScore ); response.certaintySummary = this.deps.metricsCalculator.generateCertaintySummary( verification.status as VerificationStatus, response.reliabilityScore ); if (verification.verifiedCalculations?.length) { response.thought = this.deps.verificationService.annotateThoughtWithVerifications( response.thought, verification.verifiedCalculations ); thoughtGraph.updateThoughtContent(thoughtId, response.thought); } tracker.complete(deepVerificationStep, { status: verification.status, verifiedCalculations: verification.verifiedCalculations?.length || 0 }); } catch (error) { tracker.fail(deepVerificationStep, error); response.verificationStatus = 'inconclusive'; response.certaintySummary = `Erreur lors de la vérification: ${error instanceof Error ? error.message : 'Erreur inconnue'}. Niveau de confiance: ${Math.round(metrics.confidence * 100)}%.`; } } if (params.suggestTools) { const toolStep = tracker.start('suggestion', 'Suggestion d’outils', 'Identification des outils pertinents', [evaluationStep]); response.suggestedTools = await this.deps.toolIntegrator.suggestTools(params.thought); tracker.complete(toolStep, { suggestions: response.suggestedTools.length }); } if (params.generateVisualization) { const visualizationStep = tracker.start('visualization', 'Visualisation du graphe', 'Construction des vues demandées', [graphStep]); try { response.visualization = await this.generateVisualization(thoughtGraph, thoughtId, params); tracker.complete(visualizationStep, { nodeCount: response.visualization?.nodes.length || 0, linkCount: response.visualization?.links.length || 0 }); } catch (error) { tracker.fail(visualizationStep, error); } } const memoryStep = tracker.start('memory', 'Mémorisation', 'Mise à jour de la mémoire persistante', [evaluationStep]); const tags = params.thought .toLowerCase() .split(/\W+/) .filter(word => word.length > 4) .slice(0, 5); await Promise.resolve(this.deps.memoryManager.addMemory(response.thought, tags, sessionId)); response.relevantMemories = await this.deps.memoryManager.getRelevantMemories(params.thought, 3, sessionId); tracker.complete(memoryStep, { storedTags: tags.length, relevantMemories: response.relevantMemories.length }); const suggestionStep = tracker.start('planning', 'Prochaines étapes', 'Génération de suggestions de raisonnement', [evaluationStep]); response.suggestedNextSteps = await thoughtGraph.suggestNextSteps(3, sessionId); tracker.complete(suggestionStep, { suggestions: response.suggestedNextSteps.length }); const persistenceStep = tracker.start('persistence', 'Sauvegarde du graphe', 'Persistances des données de session', [graphStep]); const graphState = thoughtGraph.exportEnrichedGraph(); await this.deps.memoryManager.saveGraphState(sessionId, graphState); tracker.complete(persistenceStep, { persisted: true }); response.reasoningTrace = tracker.getSteps(); response.reasoningTimeline = tracker.getTimeline().map(item => ({ stepId: item.stepId, label: item.label, status: item.status, timestamp: item.timestamp })); return { response, sessionId, thoughtGraph };
• src/server/smart-thinking-server.ts:126-192 (registration)

  Registers the 'smartthinking' MCP tool on the server with name 'smartthinking', input schema, and handler that delegates to ReasoningOrchestrator.run().
  function createSmartThinkingTool(server: McpServer, env: SmartThinkingEnvironment): void { server.tool( 'smartthinking', SmartThinkingParamsSchema.shape, async (params: SmartThinkingParams) => { if (params.help && !params.thought) { return { content: [ { type: 'text', text: `# Smart-Thinking - Guide d'utilisation Smart-Thinking est un outil de raisonnement multi-dimensionnel qui organise les pensées en graphe plutôt qu'en séquence linéaire, permettant une analyse plus riche et interconnectée des problèmes complexes. ## Paramètres principaux - thought (obligatoire) : pensée à analyser - thoughtType : regular | revision | meta | hypothesis | conclusion - connections : [{ targetId, type, strength }] - requestSuggestions : activer les recommandations - generateVisualization : produire un graphe - requestVerification : lancer une vérification explicite - containsCalculations : vérifier les calculs mathématiques ## Types de visualisation - graph, chronological, thematic, hierarchical, force, radial ## Exemple d'utilisation thought: "L'intelligence artificielle transformera le marché du travail" thoughtType: "hypothesis" generateVisualization: true` } ] }; } if (!params.thought) { return { isError: true, content: [ { type: 'text', text: JSON.stringify({ error: "Le paramètre 'thought' est obligatoire.", message: "Vous devez fournir une pensée à analyser." }, null, 2) } ] }; } const { response, sessionId } = await env.orchestrator.run(params); const payload: SmartThinkingResponse & { sessionId?: string } = { ...response, sessionId }; return { content: [ { type: 'text', text: JSON.stringify(payload, null, 2) } ], structuredContent: payload as unknown as Record<string, unknown> }; } );
• src/server/smart-thinking-server.ts:89-103 (schema)

  Zod input schema (SmartThinkingParamsSchema) defining all parameters for the smartthinking tool, including enums for types, options for visualization, verification, etc.
  export const SmartThinkingParamsSchema = z.object({ thought: z.string().describe('Le contenu de la pensée à analyser - PARAMÈTRE OBLIGATOIRE'), thoughtType: ThoughtTypeEnum.default('regular').describe('Type de pensée dans le graphe de raisonnement'), connections: z.array(ConnectionSchema).default([]).describe('Connexions à d\'autres pensées'), requestSuggestions: z.boolean().default(false).describe('Demander des suggestions d\'amélioration du raisonnement'), generateVisualization: z.boolean().default(false).describe('Générer une visualisation du graphe de pensée'), visualizationType: VisualizationTypeEnum.default('graph').describe('Type de visualisation à générer'), suggestTools: z.boolean().default(true).describe('Suggérer des outils MCP pertinents pour cette étape du raisonnement'), sessionId: z.string().optional().describe('Identifiant de session pour maintenir l\'état'), userId: z.string().optional().describe('Identifiant de l\'utilisateur pour la personnalisation'), help: z.boolean().default(true).describe('Afficher le guide d\'utilisation complet'), requestVerification: z.boolean().default(false).describe('Demander explicitement une vérification des informations'), containsCalculations: z.boolean().default(false).describe('Indique si la pensée contient des calculs à vérifier'), visualizationOptions: VisualizationOptionsSchema.describe('Options avancées pour la visualisation') });
• src/server/smart-thinking-server.ts:324-343 (registration)

  Main server creation function that conditionally registers the smartthinking tool via createSmartThinkingTool.
  export function createSmartThinkingServer( env?: SmartThinkingEnvironment, options?: SmartThinkingServerOptions ): { server: McpServer; env: SmartThinkingEnvironment } { const environment = env ?? getSmartThinkingEnvironment(); const server = new McpServer({ name: 'smart-thinking-mcp', version: environment.version }, { capabilities: {} }); const { includeSmartThinkingTool = true } = options ?? {}; if (includeSmartThinkingTool) { createSmartThinkingTool(server, environment); } createSearchTool(server, environment); createFetchTool(server, environment); return { server, env: environment }; }