get_all_memories

Instructions

Implementation Reference

• src/index.ts:953-985 (handler)

  MCP tool handler for 'get_all_memories': parses input arguments, calls MemoryBoxClient.getAllMemories(), formats and returns the list of memories.

  case "get_all_memories": {
    const options = {
      all: Boolean(request.params.arguments?.all || false),
      bucketId: request.params.arguments?.bucket_id ? String(request.params.arguments.bucket_id) : undefined,
      sourceType: request.params.arguments?.source_type ? String(request.params.arguments.source_type) : undefined,
      limit: request.params.arguments?.limit ? Number(request.params.arguments.limit) : undefined,
      offset: request.params.arguments?.offset ? Number(request.params.arguments.offset) : undefined,
      includeReferenceData: Boolean(request.params.arguments?.include_reference_data || false),
      dateSort: Boolean(request.params.arguments?.date_sort || false),
      sortOrder: request.params.arguments?.sort_order as 'asc' | 'desc' | undefined
    };
  
    // Get memories
    const result = await memoryBoxClient.getAllMemories(options);
  
    // Format the results
    let responseText = "All memories:\n\n";
    
    if (result.items && result.items.length > 0) {
      result.items.forEach((memory: any, index: number) => {
        responseText += `${index + 1}. [${memory.bucket_id}] ${memory.text}\n\n`;
      });
    } else {
      responseText += "No memories found.";
    }
  
    return {
      content: [{
        type: "text",
        text: responseText
      }]
    };
  }

• src/index.ts:211-256 (helper)

  MemoryBoxClient.getAllMemories(): API client method that fetches all memories from the Memory Box API using GET /api/v2/memory with query parameters.

  async getAllMemories(options?: {
    all?: boolean;
    bucketId?: string;
    sourceType?: string;
    limit?: number;
    offset?: number;
    includeReferenceData?: boolean;
    dateSort?: boolean;
    sortOrder?: 'asc' | 'desc';
  }): Promise<any> {
    try {
      const params: any = {};
      
      if (options) {
        if (options.all !== undefined) params.all = options.all;
        if (options.bucketId !== undefined) params.bucketId = options.bucketId;
        if (options.sourceType !== undefined) params.source_type = options.sourceType;
        if (options.limit !== undefined) params.limit = options.limit;
        if (options.offset !== undefined) params.offset = options.offset;
        if (options.includeReferenceData !== undefined) params.include_reference_data = options.includeReferenceData;
        if (options.dateSort !== undefined) params.date_sort = options.dateSort;
        if (options.sortOrder !== undefined) params.sort_order = options.sortOrder;
      } else {
        params.all = true; // Default behavior for backward compatibility
      }
  
      const response = await axios.get(
        `${this.baseUrl}/api/v2/memory`,
        {
          params,
          headers: {
            "Authorization": `Bearer ${this.token}`
          }
        }
      );
      return response.data;
    } catch (error) {
      if (axios.isAxiosError(error)) {
        throw new McpError(
          ErrorCode.InternalError,
          `Failed to get all memories: ${error.response?.data?.detail || error.message}`
        );
      }
      throw error;
    }
  }

• src/index.ts:658-702 (registration)

  Tool registration in ListToolsRequestSchema handler: defines name, description, and inputSchema for get_all_memories.

  {
    name: "get_all_memories",
    description: "Retrieve all memories with pagination support",
    inputSchema: {
      type: "object",
      properties: {
        all: {
          type: "boolean",
          description: "Get all memories (overrides pagination, default: false)"
        },
        bucket_id: {
          type: "string",
          description: "Filter to specific bucket"
        },
        source_type: {
          type: "string",
          description: "Filter by source type"
        },
        limit: {
          type: "integer",
          description: "Maximum number of results to return (1-100, default: 10)",
          minimum: 1,
          maximum: 100
        },
        offset: {
          type: "integer",
          description: "Number of results to skip for pagination (default: 0)",
          minimum: 0
        },
        include_reference_data: {
          type: "boolean",
          description: "Include reference data in response (default: false)"
        },
        date_sort: {
          type: "boolean",
          description: "Sort results by date (default: false)"
        },
        sort_order: {
          type: "string",
          description: "Sort order (default: 'desc')",
          enum: ["asc", "desc"]
        }
      }
    }
  },

• src/index.ts:661-701 (schema)

  Input schema definition for get_all_memories tool, specifying parameters for filtering, pagination, and sorting memories.

  inputSchema: {
    type: "object",
    properties: {
      all: {
        type: "boolean",
        description: "Get all memories (overrides pagination, default: false)"
      },
      bucket_id: {
        type: "string",
        description: "Filter to specific bucket"
      },
      source_type: {
        type: "string",
        description: "Filter by source type"
      },
      limit: {
        type: "integer",
        description: "Maximum number of results to return (1-100, default: 10)",
        minimum: 1,
        maximum: 100
      },
      offset: {
        type: "integer",
        description: "Number of results to skip for pagination (default: 0)",
        minimum: 0
      },
      include_reference_data: {
        type: "boolean",
        description: "Include reference data in response (default: false)"
      },
      date_sort: {
        type: "boolean",
        description: "Sort results by date (default: false)"
      },
      sort_order: {
        type: "string",
        description: "Sort order (default: 'desc')",
        enum: ["asc", "desc"]
      }
    }
  }