Unconventional-thinking MCP server

Instructions

Implementation Reference

• src/index.ts:169-212 (handler)

  MCP tool handler in CallToolRequestSchema switch statement. Parses input arguments, generates thought metadata, calls core generateUnreasonableThought function, persists to file, returns resource URI and metadata without full content.

  case "generate_unreasonable_thought": {
    const { problem, previousThoughtId, forceRebellion } = request.params.arguments as any;
  
    const thoughtId = `thought_${Date.now()}`;
    const isRebellion = forceRebellion || Math.random() > 0.5;
  
    const thoughts = loadThoughts();
    let branchId;
    if (previousThoughtId) {
      const previousThought = thoughts[previousThoughtId];
      if (!previousThought) {
        throw new McpError(ErrorCode.InvalidParams, "Previous thought not found");
      }
      branchId = previousThought.branchId;
    }
  
    const thought: Thought = {
      id: thoughtId,
      content: generateUnreasonableThought(problem, previousThoughtId ? thoughts[previousThoughtId] : undefined),
      isRebellion,
      challengesAssumption: Math.random() > 0.3,
      branchFromThought: previousThoughtId,
      branchId,
      timestamp: Date.now()
    };
  
    thoughts[thoughtId] = thought;
    saveThoughts(thoughts);
  
    // Return only essential metadata, not full content - saves context
    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          thoughtId,
          resourceUri: `thought://${thoughtId}`,
          isRebellion: thought.isRebellion,
          challengesAssumption: thought.challengesAssumption,
          branchInfo: thought.branchId ? `Branch: ${thought.branchId}` : "Main branch",
          message: "Thought generated. Use resource URI to access full content."
        }, null, 2)
      }]
    };
  }

• src/index.ts:64-81 (schema)

  Input schema defining parameters for the generate_unreasonable_thought tool: problem (required), previousThoughtId (optional), forceRebellion (optional).

  inputSchema: {
    type: "object",
    properties: {
      problem: {
        type: "string",
        description: "The problem or challenge to think unreasonably about"
      },
      previousThoughtId: {
        type: "string",
        description: "Optional ID of a previous thought to build upon or rebel against"
      },
      forceRebellion: {
        type: "boolean",
        description: "Force the thought to rebel against conventional wisdom"
      }
    },
    required: ["problem"]
  }

• src/index.ts:61-82 (registration)

  Tool registration in ListToolsRequestSchema handler, including name, description, and input schema.

  {
    name: "generate_unreasonable_thought",
    description: "Generate a new unreasonable thought that challenges conventional thinking. Efficiently creates thoughts without loading full context.",
    inputSchema: {
      type: "object",
      properties: {
        problem: {
          type: "string",
          description: "The problem or challenge to think unreasonably about"
        },
        previousThoughtId: {
          type: "string",
          description: "Optional ID of a previous thought to build upon or rebel against"
        },
        forceRebellion: {
          type: "boolean",
          description: "Force the thought to rebel against conventional wisdom"
        }
      },
      required: ["problem"]
    }
  },

• src/index.ts:293-312 (helper)

  Core helper function that implements the unreasonable thought generation logic using predefined templates and randomization, optionally building on a previous thought.

  function generateUnreasonableThought(problem: string, previousThought?: Thought): string {
    const unreasonableApproaches = [
      `What if we completely eliminated the concept of ${problem}?`,
      `Imagine if ${problem} operated in reverse - what opportunities would that create?`,
      `If we had infinite resources and no physical limitations, how would we solve ${problem}?`,
      `What if we combined ${problem} with its exact opposite?`,
      `How would an alien civilization with completely different logic solve ${problem}?`,
      `What if the opposite of "${problem}" is actually the better solution?`,
      `What if we scaled ${problem} up 1000x - what becomes possible?`,
      `What if we removed all constraints from ${problem} - what changes?`
    ];
  
    let thought = unreasonableApproaches[Math.floor(Math.random() * unreasonableApproaches.length)];
  
    if (previousThought) {
      thought = `Building on: ${previousThought.content}\n\nNew angle: ${thought}`;
    }
  
    return thought;
  }