smartthinking

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 };
  }