AoT-light

Instructions

Implementation Reference

• src/index.ts:650-710 (schema)

  Tool schema definition for 'AoT-light' including name, description, and input schema with properties for atomId, content, atomType, dependencies, confidence, etc.

  const AOT_LIGHT_TOOL: Tool = {
    name: "AoT-light",
    description: `A lightweight version of Atom of Thoughts (AoT) designed for faster processing and quicker results.
  This streamlined version sacrifices some depth of analysis for speed, making it ideal for time-sensitive reasoning tasks.
  
  When to use:
  - Quick brainstorming sessions requiring atomic thought organization
  - Time-sensitive problem solving where speed is prioritized over exhaustive analysis
  - Simpler reasoning tasks that don't require deep decomposition
  - Initial exploration before using the full AoT for deeper analysis
  - Learning or demonstration purposes where response time is important
  
  Key differences from full AoT:
  - Lower maximum depth (3 instead of 5) for faster processing
  - Simplified verification process
  - Immediate conclusion suggestion for high-confidence hypotheses
  - Reduced computational overhead and response payload
  - Optimized for speed rather than exhaustive analysis
  
  Atom types and parameters are the same as the full AoT tool.`,
    inputSchema: {
      type: "object",
      properties: {
        atomId: {
          type: "string",
          description: "Unique identifier for the atom"
        },
        content: {
          type: "string",
          description: "Actual content of the atom"
        },
        atomType: {
          type: "string",
          enum: ["premise", "reasoning", "hypothesis", "verification", "conclusion"],
          description: "Type of atom"
        },
        dependencies: {
          type: "array",
          items: {
            type: "string"
          },
          description: "List of IDs of other atoms this atom depends on"
        },
        confidence: {
          type: "number",
          minimum: 0,
          maximum: 1,
          description: "Confidence level of this atom (value between 0-1)"
        },
        isVerified: {
          type: "boolean",
          description: "Whether this atom has been verified"
        },
        depth: {
          type: "number",
          description: "Depth level of this atom (optional, defaults to 0)"
        }
      },
      required: ["atomId", "content", "atomType", "dependencies", "confidence"]
    }
  };

• src/index.ts:771-773 (registration)

  Registration of 'AoT-light' tool in the ListToolsRequestSchema handler by including AOT_LIGHT_TOOL in the tools array.

  server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: [AOT_TOOL, AOT_LIGHT_TOOL, ATOM_COMMANDS_TOOL],
  }));

• src/index.ts:778-779 (handler)

  Dispatch handler in CallToolRequestSchema: if name === 'AoT-light', calls atomLightServer.processAtom(request.params.arguments).

  } else if (request.params.name === "AoT-light") {
    return atomLightServer.processAtom(request.params.arguments);

• src/index.ts:486-558 (handler)

  AtomOfThoughtsLightServer class extending AtomOfThoughtsServer, with constructor setting maxDepth=3 and overridden processAtom method implementing the lightweight tool logic.

  class AtomOfThoughtsLightServer extends AtomOfThoughtsServer {
    constructor() {
      // Lower max depth for faster processing
      super(3);
    }
  
    // Override to simplify the verification process
    public processAtom(input: unknown): { content: Array<{ type: string; text: string }>; isError?: boolean } {
      try {
        const validatedInput = this.validateAtomData(input);
        
        // Store the atom
        this.atoms[validatedInput.atomId] = validatedInput;
        
        // Add to order if it's new
        if (!this.atomOrder.includes(validatedInput.atomId)) {
          this.atomOrder.push(validatedInput.atomId);
        }
  
        // Format and display the atom with simplified output
        const formattedAtom = this.formatAtom(validatedInput);
        console.error(formattedAtom);
  
        // Quick verification - if verification atom, immediately verify dependencies
        if (validatedInput.atomType === 'verification' && validatedInput.isVerified) {
          validatedInput.dependencies.forEach(depId => {
            if (this.atoms[depId]) {
              this.verifyAtom(depId, true);
            }
          });
        }
  
        // Faster conclusion suggestion - if hypothesis with high confidence, suggest conclusion immediately
        if (validatedInput.atomType === 'hypothesis' && validatedInput.confidence >= 0.8) {
          this.suggestConclusion(validatedInput);
        }
  
        // Simplified termination check
        const shouldTerminate = this.shouldTerminate();
        const bestConclusion = shouldTerminate ? this.getBestConclusion() : null;
        
        // Basic response with less processing
        return {
          content: [{
            type: "text",
            text: JSON.stringify({
              atomId: validatedInput.atomId,
              atomType: validatedInput.atomType,
              isVerified: validatedInput.isVerified,
              confidence: validatedInput.confidence,
              atomsCount: Object.keys(this.atoms).length,
              bestConclusion: bestConclusion ? {
                atomId: bestConclusion.atomId,
                content: bestConclusion.content,
                confidence: bestConclusion.confidence
              } : null
            }, null, 2)
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: "text",
            text: JSON.stringify({
              error: error instanceof Error ? error.message : String(error),
              status: 'failed'
            }, null, 2)
          }],
          isError: true
        };
      }
    }
  }

• src/index.ts:769-769 (helper)

  Creation of atomLightServer instance: const atomLightServer = new AtomOfThoughtsLightServer(); used by the AoT-light handler.

  const atomLightServer = new AtomOfThoughtsLightServer();