diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1b105c342137..be4cb62c2311 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -7,6 +7,7 @@ name: Ubuntu
           - master
           - develop
           - feature/**
+          - lru_miltiindex_prototype
 
 env:
     JAVA_HOME: /usr/lib/jvm/java-17-openjdk-amd64
diff --git a/cmake/install/userver-multi-index-lru-config.cmake b/cmake/install/userver-multi-index-lru-config.cmake
new file mode 100644
index 000000000000..28acce8da7a8
--- /dev/null
+++ b/cmake/install/userver-multi-index-lru-config.cmake
@@ -0,0 +1,11 @@
+include_guard(GLOBAL)
+
+if(userver_multiindex_lru_FOUND)
+    return()
+endif()
+
+find_package(userver REQUIRED COMPONENTS core)
+
+find_package(Boost REQUIRED) 
+
+set(userver_multiindex_lru_FOUND TRUE)
diff --git a/libraries/CMakeLists.txt b/libraries/CMakeLists.txt
index 36dfc73798f3..21ba4f303f65 100644
--- a/libraries/CMakeLists.txt
+++ b/libraries/CMakeLists.txt
@@ -2,11 +2,16 @@ option(USERVER_FEATURE_EASY "Build easy HTTP server library" "${USERVER_LIB_ENAB
 option(USERVER_FEATURE_S3API "Build S3 api client library" "${USERVER_LIB_ENABLED_DEFAULT}")
 option(USERVER_FEATURE_GRPC_REFLECTION "Build grpc reflection library" "${USERVER_LIB_ENABLED_DEFAULT}")
 option(USERVER_FEATURE_GRPC_PROTOVALIDATE "Build grpc protovalidate library" "OFF")
+option(USERVER_FEATURE_MULTI_INDEX_LRU "Build multi index lru library" "ON")
 
 if(USERVER_FEATURE_S3API)
     add_subdirectory(s3api)
 endif()
 
+if (USERVER_FEATURE_MULTI_INDEX_LRU)
+    add_subdirectory(multi_index_lru)
+endif()
+
 if(USERVER_FEATURE_EASY)
     if(NOT USERVER_FEATURE_POSTGRESQL)
         message(FATAL_ERROR "'USERVER_FEATURE_EASY' requires 'USERVER_FEATURE_POSTGRESQL=ON'")
diff --git a/libraries/multi_index_lru/CMakeLists.txt b/libraries/multi_index_lru/CMakeLists.txt
new file mode 100644
index 000000000000..b610d719d1f9
--- /dev/null
+++ b/libraries/multi_index_lru/CMakeLists.txt
@@ -0,0 +1,23 @@
+project(userver-multi-index-lru CXX)
+
+find_package(Boost REQUIRED)
+
+userver_module(
+    multi-index-lru
+    SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}"
+    UTEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*_test.cpp"
+    UBENCH_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*_benchmark.cpp"
+    DEPENDS core
+)
+
+target_include_directories(userver-multi-index-lru
+    PUBLIC
+        ${Boost_INCLUDE_DIRS}
+        "${CMAKE_CURRENT_SOURCE_DIR}/tests/"
+)
+
+_userver_directory_install(
+    COMPONENT multi-index-lru
+    FILES "${USERVER_ROOT_DIR}/cmake/modules/Findboost.cmake"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/userver/modules"
+)
\ No newline at end of file
diff --git a/libraries/multi_index_lru/include/userver/multi_index_lru/lru_boost_list_container.h b/libraries/multi_index_lru/include/userver/multi_index_lru/lru_boost_list_container.h
new file mode 100644
index 000000000000..9f5c31ae7f88
--- /dev/null
+++ b/libraries/multi_index_lru/include/userver/multi_index_lru/lru_boost_list_container.h
@@ -0,0 +1,193 @@
+#pragma once
+
+#include <boost/intrusive/link_mode.hpp>
+#include <boost/intrusive/list.hpp>
+#include <boost/intrusive/list_hook.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/mem_fun.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace multi_index_lru {
+using namespace boost::multi_index;
+
+namespace impl {
+template<typename Value>
+struct ValueWithHook
+{
+    Value value;
+    mutable boost::intrusive::list_member_hook<> list_hook;
+    const ValueWithHook *GetPointerToSelf() const { return this; };
+
+    explicit ValueWithHook(const Value& val) : value(val) {}
+        
+    explicit ValueWithHook(Value&& val) : value(std::move(val)) {}
+    
+    ValueWithHook() = delete;
+    ValueWithHook(const ValueWithHook&) = delete;
+    ValueWithHook(ValueWithHook &&) = delete;
+
+    ValueWithHook &operator=(const ValueWithHook&) = delete;
+    ValueWithHook &operator=(ValueWithHook&&) = delete;
+    
+    operator Value&() { return value; }
+    operator const Value&() const { return value; }
+    
+    Value* operator->() { return &value; }
+    const Value* operator->() const { return &value; }
+    
+    Value& get() { return value; }
+    const Value& get() const { return value; }
+
+    using boost_list = boost::intrusive::list<
+                            ValueWithHook,
+                            boost::intrusive::member_hook<
+                                ValueWithHook,
+                                boost::intrusive::list_member_hook<>, 
+                                &ValueWithHook::list_hook
+                            >
+                        >;
+
+    void push_back_to_list(boost_list &lst) const {
+        lst.push_back(const_cast<ValueWithHook&>(*this));
+    }
+
+    void splice_in_list(boost_list &lst) const {
+        lst.splice(lst.end(), lst, lst.iterator_to(const_cast<ValueWithHook&>(*this)));
+    }
+};
+
+struct internal_ptr_tag {};
+} // namespace impl
+
+template<
+    typename Value,
+    typename IndexSpecifierList,
+    typename Allocator = std::allocator<impl::ValueWithHook<Value>>
+>
+class LRUCacheContainer {
+private:
+    using CacheItem = impl::ValueWithHook<Value>;
+    using List =  boost::intrusive::list<
+                        CacheItem,
+                        boost::intrusive::member_hook<
+                            CacheItem,
+                            boost::intrusive::list_member_hook<>, 
+                            &CacheItem::list_hook
+                        >
+                    >;
+
+    using ExtendedIndexSpecifierList = typename boost::mpl::push_back<
+        IndexSpecifierList,
+        hashed_unique<
+            tag<impl::internal_ptr_tag>,
+            const_mem_fun<CacheItem, const CacheItem*, &CacheItem::GetPointerToSelf>
+        >
+    >::type;
+
+    using Container = multi_index_container<
+        CacheItem,
+        ExtendedIndexSpecifierList,
+        Allocator
+    >;
+
+    Container container;
+    size_t max_size;
+
+    List usage_list;
+    
+public:
+    using value_type = Value;
+    using cache_item_type = CacheItem;
+    
+    LRUCacheContainer(size_t max_size) : max_size(max_size) {}
+    
+    template<typename... Args>
+    bool emplace(Args&&... args) {
+        if (container.size() >= max_size) {
+            evict_lru();
+        }
+        
+        auto result = container.emplace(std::forward<Args>(args)...);
+
+        auto &value = *result.first;
+        if (result.second) {
+            value.push_back_to_list(usage_list);
+        } else {
+            value.splice_in_list(usage_list);
+        }
+        return result.second;
+    }
+    
+    bool insert(const Value& value) {
+        return emplace(value);
+    }
+    
+    bool insert(Value&& value) {
+        return emplace(std::move(value));
+    }
+    
+    template<typename Tag, typename Key>
+    typename Container::template index<Tag>::type::iterator find(const Key& key) {
+        auto& primary_index = container.template get<Tag>();
+        auto it = primary_index.find(key);
+        
+        if (it != primary_index.end()) {
+            it->splice_in_list(usage_list);
+        }
+        
+        return it;
+    }
+    
+    template<typename Tag, typename Key>
+    bool contains(const Key& key) {
+        return this->template find<Tag, Key>(key) != container.template get<Tag>().end();
+    }
+    
+    template<typename Tag, typename Key>
+    bool erase(const Key& key) {
+        auto& primary_index = container.template get<Tag>();
+        auto it = primary_index.find(key);
+        if (it != primary_index.end()) {
+            usage_list.erase(usage_list.iterator_to(*it));
+        }
+        return container.template get<Tag>().erase(key) > 0;
+    }
+    
+    template<typename Tag>
+    auto& get() {
+        return container.template get<Tag>();
+    }
+    
+    template<typename Tag>
+    const auto& get() const {
+        return container.template get<Tag>();
+    }
+    
+    size_t size() const { return container.size(); }
+    bool empty() const { return container.empty(); }
+    size_t capacity() const { return max_size; }
+    
+    void set_capacity(size_t new_capacity) {
+        max_size = new_capacity;
+        while (container.size() > max_size) {
+            evict_lru();
+        }
+    }
+    
+    void clear() {
+        container.clear();
+    }
+    
+private:
+    void evict_lru() {
+        if (!usage_list.empty()) {
+            CacheItem *ptr_to_erase = &*usage_list.begin();
+            usage_list.erase(usage_list.begin());
+            container.template get<impl::internal_ptr_tag>().erase(ptr_to_erase);
+        }
+    }
+};
+} // namespace multi_index_lru
+
+USERVER_NAMESPACE_END
\ No newline at end of file
diff --git a/libraries/multi_index_lru/library.yaml b/libraries/multi_index_lru/library.yaml
new file mode 100644
index 000000000000..91039f89479f
--- /dev/null
+++ b/libraries/multi_index_lru/library.yaml
@@ -0,0 +1,9 @@
+project-name: userver-lib-multi-index-lru
+
+description: multi index lru cache
+
+maintainers:
+  - Common components
+
+libraries:
+  - userver-core
diff --git a/libraries/multi_index_lru/src/main_benchmark.cpp b/libraries/multi_index_lru/src/main_benchmark.cpp
new file mode 100644
index 000000000000..c8f23c3dc800
--- /dev/null
+++ b/libraries/multi_index_lru/src/main_benchmark.cpp
@@ -0,0 +1,16 @@
+#include "benchmarks/lru_basic_benchmarks.h"
+#include "benchmarks/lru_google_benchmarks.h"
+
+// #define LRU_CONTAINER_DEBUG__
+#include <userver/multi_index_lru/lru_boost_list_container.h>
+
+using namespace USERVER_NAMESPACE;
+
+int main() {
+    benchmarks::simple_benchmark<multi_index_lru::LRUCacheContainer>("boost_list_output.txt");
+    benchmarks::google_benchmark<multi_index_lru::LRUCacheContainer>();
+
+    benchmarks::google_benchmark_init("google_output.txt");
+    benchmarks::google_benchmark_run();
+    return 0;
+}
\ No newline at end of file
diff --git a/libraries/multi_index_lru/src/main_test.cpp b/libraries/multi_index_lru/src/main_test.cpp
new file mode 100644
index 000000000000..a16f4140a393
--- /dev/null
+++ b/libraries/multi_index_lru/src/main_test.cpp
@@ -0,0 +1,13 @@
+#include "tests/lru_basic_tests.h"
+
+// #define LRU_CONTAINER_DEBUG__
+#include <userver/multi_index_lru/lru_boost_list_container.h>
+
+using namespace USERVER_NAMESPACE;
+
+int main() {
+    test_lru_users<multi_index_lru::LRUCacheContainer>();
+    test_lru_products<multi_index_lru::LRUCacheContainer>();
+    std::cout << "all tests success" << std::endl; 
+    return 0;
+}
\ No newline at end of file
diff --git a/libraries/multi_index_lru/src/multi_index_lru.cpp b/libraries/multi_index_lru/src/multi_index_lru.cpp
new file mode 100644
index 000000000000..bdb5f8542d7c
--- /dev/null
+++ b/libraries/multi_index_lru/src/multi_index_lru.cpp
@@ -0,0 +1,3 @@
+#include <userver/multi_index_lru/lru_boost_list_container.h>
+
+namespace userver::multi_index_lru { const char* multi_index_lru_version = "1.0"; }
diff --git a/libraries/multi_index_lru/tests/benchmarks/benchmarks_resourses.h b/libraries/multi_index_lru/tests/benchmarks/benchmarks_resourses.h
new file mode 100644
index 000000000000..a9d5e3acf9fc
--- /dev/null
+++ b/libraries/multi_index_lru/tests/benchmarks/benchmarks_resourses.h
@@ -0,0 +1,60 @@
+#pragma once
+
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <vector>
+#include <random>
+#include <chrono>
+#include <iomanip>
+
+#include "../lru_container_concept.h" 
+
+USERVER_NAMESPACE_BEGIN
+
+namespace benchmarks {
+
+const std::vector<long long> CACHE_SIZES = {1000, 10000, 100000};
+const size_t OPERATIONS_NUMBER = 100000;
+const int MAX_ID_SIZE = 50000;
+
+struct id_tag {};
+struct email_tag {};
+struct name_tag {};
+
+struct User {
+    int id;
+    std::string email;
+    std::string name;
+    
+    bool operator==(const User& other) const {
+        return id == other.id && email == other.email && name == other.name;
+    }
+};
+
+namespace generator {
+std::random_device rd;
+std::mt19937 gen(rd());
+std::uniform_real_distribution<double> action_dist(0.0, 1.0);
+std::uniform_int_distribution<int> id_dist(0, MAX_ID_SIZE);
+
+User generate_user() {
+    std::string email = "email" + std::to_string(id_dist(gen));
+    std::string name = "name" + std::to_string(id_dist(gen));
+    return User{id_dist(gen), email, name};
+}
+
+int generate_id() {
+    return id_dist(gen);
+}
+
+std::string generate_name() {
+    return "name" + std::to_string(id_dist(gen));
+}
+
+std::string generate_email() {
+    return "email" + std::to_string(id_dist(gen));
+}
+} // generator
+} // benchmarks
+USERVER_NAMESPACE_END
\ No newline at end of file
diff --git a/libraries/multi_index_lru/tests/benchmarks/lru_basic_benchmarks.h b/libraries/multi_index_lru/tests/benchmarks/lru_basic_benchmarks.h
new file mode 100644
index 000000000000..9c57fff865fc
--- /dev/null
+++ b/libraries/multi_index_lru/tests/benchmarks/lru_basic_benchmarks.h
@@ -0,0 +1,90 @@
+#pragma once
+
+#include "benchmarks_resourses.h"
+
+USERVER_NAMESPACE_BEGIN
+
+namespace benchmarks {
+
+using namespace boost::multi_index;
+
+template<
+    template<typename, typename, typename> class LRUCacheContainer
+>
+void simple_benchmark(std::string &&output_filename) {
+
+    using UserCache = LRUCacheContainer<
+        User,
+        indexed_by<
+            ordered_unique<tag<id_tag>, member<User, int, &User::id>>,
+            ordered_unique<tag<email_tag>, member<User, std::string, &User::email>>,
+            ordered_non_unique<tag<name_tag>, member<User, std::string, &User::name>>
+        >,
+        std::allocator<User>
+    >;
+
+    lru_concept_assert_for_one_tag(UserCache, id_tag, int, User);
+    lru_concept_assert_for_one_tag(UserCache, email_tag, std::string, User);
+    lru_concept_assert_for_one_tag(UserCache, name_tag, std::string, User);
+
+    std::ofstream output_file(output_filename, std::ios::app);
+    if (!output_file.is_open()) {
+        std::cerr << "Failed to open output file: " << output_filename << std::endl;
+        return;
+    }
+
+    output_file << std::left << std::setw(20) << "Operations count" 
+                << std::setw(16) << "Cache size" 
+                << std::setw(12) << "Time (ms)" 
+                << std::endl;
+    output_file << std::string(50, '-') << std::endl;
+
+    for (const size_t size : CACHE_SIZES) {
+        UserCache cache(size);
+        for (size_t i = 0; i < size; ++i) {
+            cache.emplace(generator::generate_user());
+        }
+
+        size_t reading_operations_number = OPERATIONS_NUMBER * 4 / 5;
+        size_t writing_operations_number = OPERATIONS_NUMBER / 5;
+
+        std::vector<std::string> names, emails;
+        std::vector<int> ids;
+        std::vector<User> users;
+        
+        for (size_t i = 0; i < reading_operations_number; ++i) {
+            names.push_back(generator::generate_name());
+            emails.push_back(generator::generate_email());
+            ids.push_back(generator::generate_id());
+        }
+
+        for (size_t i = 0; i < writing_operations_number; ++i) {
+            users.push_back(generator::generate_user());
+        }
+
+        auto start_time = std::chrono::high_resolution_clock::now();
+        
+        for (size_t i = 0; i < reading_operations_number; ++i) {
+            cache.template find<name_tag, std::string>(names[i]);
+            cache.template find<email_tag, std::string>(emails[i]);
+            cache.template find<id_tag, int>(ids[i]);
+        }
+
+        for (size_t i = 0; i < writing_operations_number; ++i) {
+            cache.emplace(users[i]);
+        }
+
+        auto end_time = std::chrono::high_resolution_clock::now();
+        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
+
+        output_file << std::left << std::setw(20) << OPERATIONS_NUMBER
+                    << std::setw(16) << size 
+                    << std::setw(12) << elapsed.count()
+                    << std::endl;
+        output_file << std::string(50, '-') << std::endl;
+    }
+
+    output_file.close();
+}
+} // benchmarks
+USERVER_NAMESPACE_END
\ No newline at end of file
diff --git a/libraries/multi_index_lru/tests/benchmarks/lru_google_benchmarks.h b/libraries/multi_index_lru/tests/benchmarks/lru_google_benchmarks.h
new file mode 100644
index 000000000000..82f80e02c9cd
--- /dev/null
+++ b/libraries/multi_index_lru/tests/benchmarks/lru_google_benchmarks.h
@@ -0,0 +1,140 @@
+#pragma once
+
+#include <benchmark/benchmark.h>
+#include "benchmarks_resourses.h"
+
+USERVER_NAMESPACE_BEGIN
+
+namespace benchmarks {
+
+using namespace boost::multi_index;
+
+template<
+    template<typename, typename, typename> class LRUCacheContainer
+>
+class LRUCacheBenchmark {
+private:
+    using UserCache = LRUCacheContainer<
+        User,
+        indexed_by<
+            ordered_unique<tag<id_tag>, member<User, int, &User::id>>,
+            ordered_unique<tag<email_tag>, member<User, std::string, &User::email>>,
+            ordered_non_unique<tag<name_tag>, member<User, std::string, &User::name>>
+        >,
+        std::allocator<User>
+    >;
+
+    static void prepare_cache(UserCache& cache, size_t size) {
+        for (size_t i = 0; i < size; ++i) {
+            cache.emplace(generator::generate_user());
+        }
+    }
+
+public:
+    static void BM_GetOperations(::benchmark::State& state) {
+        const size_t cache_size = state.range(0);
+        const size_t operations_count = state.range(1);
+        
+        UserCache cache(cache_size);
+        prepare_cache(cache, cache_size);
+
+        for (auto _ : state) {
+            state.PauseTiming();
+            std::vector<std::string> names, emails;
+            std::vector<int> ids;
+            for (size_t i = 0; i < operations_count; ++i) {
+                names.push_back(generator::generate_name());
+                emails.push_back(generator::generate_email());
+                ids.push_back(generator::generate_id());
+            }
+            state.ResumeTiming();
+
+            for (size_t i = 0; i < operations_count; ++i) {
+                ::benchmark::DoNotOptimize(cache.template find<name_tag, std::string>(names[i]));
+                ::benchmark::DoNotOptimize(cache.template find<email_tag, std::string>(emails[i]));
+                ::benchmark::DoNotOptimize(cache.template find<id_tag, int>(ids[i]));
+            }
+        }
+
+        state.SetItemsProcessed(state.iterations() * operations_count * 3);
+        state.SetComplexityN(cache_size);
+    }
+
+    static void BM_EmplaceOperations(::benchmark::State& state) {
+        const size_t cache_size = state.range(0);
+        const size_t operations_count = state.range(1);
+        
+        UserCache cache(cache_size);
+        prepare_cache(cache, cache_size);
+
+        for (auto _ : state) {
+            state.PauseTiming();
+            std::vector<User> users;
+            for (size_t i = 0; i < operations_count; ++i) {
+                users.push_back(generator::generate_user());
+            }
+            state.ResumeTiming();
+
+            for (size_t i = 0; i < operations_count; ++i) {
+                cache.emplace(users[i]);
+            }
+        }
+
+        state.SetItemsProcessed(state.iterations() * operations_count);
+        state.SetComplexityN(cache_size);
+    }
+};
+
+void google_benchmark_init(std::string&& output_filename) {
+    std::vector<char*> args;
+    std::string prog_name = "benchmark";
+    args.push_back(prog_name.data());
+    std::string out_arg = "--benchmark_out=" + output_filename;
+    args.push_back(out_arg.data());
+    std::string format_arg = "--benchmark_out_format=json";
+    args.push_back(format_arg.data());
+    int argc = args.size();
+    ::benchmark::Initialize(&argc, args.data());
+}
+
+void google_benchmark_run() {
+    ::benchmark::RunSpecifiedBenchmarks();
+    ::benchmark::ClearRegisteredBenchmarks();
+    ::benchmark::Shutdown();
+}
+
+template<
+    template<typename, typename, typename> class LRUCacheContainer
+>
+void google_benchmark() {
+#if __cplusplus >= 202002L
+    using UserCache = LRUCacheContainer<
+        User,
+        indexed_by<
+            ordered_unique<tag<id_tag>, member<User, int, &User::id>>,
+            ordered_unique<tag<email_tag>, member<User, std::string, &User::email>>,
+            ordered_non_unique<tag<name_tag>, member<User, std::string, &User::name>>
+        >,
+        std::allocator<User>
+    >;
+
+    lru_concept_assert_for_one_tag(UserCache, id_tag, int, User);
+    lru_concept_assert_for_one_tag(UserCache, email_tag, std::string, User);
+    lru_concept_assert_for_one_tag(UserCache, name_tag, std::string, User);
+#endif
+    for (auto size : CACHE_SIZES) {
+        ::benchmark::RegisterBenchmark(
+            "GetOperations", 
+            &LRUCacheBenchmark<LRUCacheContainer>::BM_GetOperations
+        )->Args({size, OPERATIONS_NUMBER})->Unit(::benchmark::kMicrosecond);
+    }
+
+    for (auto size : CACHE_SIZES) {
+        ::benchmark::RegisterBenchmark(
+            "EmplaceOperations", 
+            &LRUCacheBenchmark<LRUCacheContainer>::BM_EmplaceOperations
+        )->Args({size, OPERATIONS_NUMBER})->Unit(::benchmark::kMicrosecond);
+    }
+}
+} // benchmarks
+USERVER_NAMESPACE_END
\ No newline at end of file
diff --git a/libraries/multi_index_lru/tests/lru_container_concept.h b/libraries/multi_index_lru/tests/lru_container_concept.h
new file mode 100644
index 000000000000..72f7d80f66a9
--- /dev/null
+++ b/libraries/multi_index_lru/tests/lru_container_concept.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "boost/multi_index_container.hpp"
+#include "boost/multi_index/ordered_index.hpp"
+#include "boost/multi_index/sequenced_index.hpp"
+#include "boost/multi_index/identity.hpp"
+#include "boost/multi_index/member.hpp"
+#include "boost/multi_index/tag.hpp"
+
+#if __cplusplus >= 202002L
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+USERVER_NAMESPACE_BEGIN
+
+template<typename T, typename Tag, typename Key, typename... Args>
+concept LRUCacheType = requires(T cache, size_t size, const Key &key, Args&&... args) {
+    T{size}; 
+    {cache.size()} -> std::same_as<size_t>;
+    {cache.empty()} -> std::same_as<bool>;
+    {cache.capacity()} -> std::same_as<size_t>;
+    {cache.clear()} -> std::same_as<void>;
+    {cache.set_capacity(size)} -> std::same_as<void>;
+
+    {cache.template find<Tag>(key)} -> std::input_iterator;
+    {cache.template contains<Tag>(key)} -> std::same_as<bool>;
+    {cache.template erase<Tag>(key)} -> std::same_as<bool>;
+    cache.template get<Tag>();
+    std::as_const(cache).template get<Tag>();
+
+    {cache.emplace(std::forward<Args>(args)...)} -> std::same_as<bool>;
+};
+
+// проверка концептом вместо наследования от абстрактного класса кэша
+#define lru_concept_assert_for_one_tag(CahceType, Tag, IndexType, ValueType) \
+    static_assert((LRUCacheType<CahceType, Tag, IndexType, const ValueType&>, "LRUCacheType concept")); \
+    static_assert((LRUCacheType<CahceType, Tag, IndexType, ValueType&&>, "LRUCacheType concept")); 
+
+USERVER_NAMESPACE_END
+#else
+#define lru_concept_assert_for_one_tag(CahceType, Tag, IndexType, ValueType)
+#endif
diff --git a/libraries/multi_index_lru/tests/tests/lru_basic_tests.h b/libraries/multi_index_lru/tests/tests/lru_basic_tests.h
new file mode 100644
index 000000000000..bf04ec512f06
--- /dev/null
+++ b/libraries/multi_index_lru/tests/tests/lru_basic_tests.h
@@ -0,0 +1,133 @@
+#pragma once
+
+#include <iostream>
+#include <string>
+#include <cassert>
+
+#include "../lru_container_concept.h"
+
+USERVER_NAMESPACE_BEGIN
+
+namespace {
+
+using namespace boost::multi_index;
+
+template<
+    template<typename, typename, typename> class LRUCacheContainer
+>
+void test_lru_users() {
+
+    struct id_tag {};
+    struct email_tag {};
+    struct name_tag {};
+
+    struct User {
+        int id;
+        std::string email;
+        std::string name;
+        
+        bool operator==(const User& other) const {
+            return id == other.id && email == other.email && name == other.name;
+        }
+    };
+
+    using UserCache = LRUCacheContainer<
+        User,
+        indexed_by<
+            ordered_unique<tag<id_tag>, member<User, int, &User::id>>,
+            ordered_unique<tag<email_tag>, member<User, std::string, &User::email>>,
+            ordered_non_unique<tag<name_tag>, member<User, std::string, &User::name>>
+        >,
+        std::allocator<User>
+    >;
+
+    lru_concept_assert_for_one_tag(UserCache, id_tag, int, User);
+    lru_concept_assert_for_one_tag(UserCache, email_tag, std::string, User);
+    lru_concept_assert_for_one_tag(UserCache, name_tag, std::string, User);
+    
+    UserCache cache(3); // capacity == 3
+    
+    cache.emplace(User{1, "alice@test.com", "Alice"});
+    cache.emplace(User{2, "bob@test.com", "Bob"});
+    cache.emplace(User{3, "charlie@test.com", "Charlie"});
+    
+    // find by id
+    [[maybe_unused]] auto by_id = cache.template get<id_tag>().find(1);
+    assert((by_id != cache.template get<id_tag>().end()));
+    assert((by_id->get().name == "Alice"));
+    
+    // find by email
+    [[maybe_unused]] auto by_email = cache.template get<email_tag>().find("bob@test.com");
+    assert((by_email != cache.template get<email_tag>().end()));
+    assert((by_email->get().id == 2));
+    
+    //find by name
+    [[maybe_unused]] auto by_name = cache.template get<name_tag>().find("Charlie");
+    assert((by_name != cache.template get<name_tag>().end()));
+    assert((by_name->get().email == "charlie@test.com"));
+    
+    //find by email
+    [[maybe_unused]] auto it = cache.template find<email_tag, std::string>("alice@test.com");
+    assert((it != cache.template get<email_tag>().end()));
+    
+    //find by id
+    cache.template find<id_tag, int>(1); 
+
+    // capacity == 3, Alice, Charlie was recently used -> Bob will be ousted 
+    cache.emplace(User{4, "david@test.com", "David"}); 
+    
+    assert((!cache.template contains<id_tag, int>(2))); // Bob outsed
+    assert((cache.template contains<id_tag, int>(1))); 
+    assert((cache.template contains<id_tag, int>(3))); 
+    assert((cache.template contains<id_tag, int>(4))); 
+
+    std::cout << "test_lru_users correct" << std::endl;
+    
+}
+
+template <template <typename, typename, typename> typename LRUCacheContainer>
+void test_lru_products() {
+
+    struct Product {
+        std::string sku;
+        std::string name;
+        double price;
+    };
+    
+    struct sku_tag {};
+    struct name_tag {};
+    
+    using ProductCache = LRUCacheContainer<
+        Product,
+        indexed_by<
+            ordered_unique<tag<sku_tag>, member<Product, std::string, &Product::sku>>,
+            ordered_unique<tag<name_tag>, member<Product, std::string, &Product::name>>
+        >,
+        std::allocator<Product>
+    >;
+
+    lru_concept_assert_for_one_tag(ProductCache, sku_tag, std::string, Product);
+    
+    ProductCache cache(2);
+    
+    cache.emplace(Product{"A1", "Laptop", 999.99});
+    cache.emplace(Product{"A2", "Mouse", 29.99});
+    
+    [[maybe_unused]] auto laptop = cache.template find<sku_tag, std::string>("A1");
+    assert((laptop != cache.template get<sku_tag>().end()));
+    
+    // A1 was used, so A2 should be ousted
+    cache.emplace(Product{"A3", "Keyboard", 79.99});
+    
+    assert((cache.template contains<sku_tag, std::string>("A1"))); // used
+    assert((cache.template contains<sku_tag, std::string>("A3"))); // new
+    assert((!cache.template contains<sku_tag, std::string>("A2"))); // ousted
+    
+    assert((cache.template get<name_tag>().find("Keyboard") != cache.template get<name_tag>().end()));
+    assert((cache.template get<name_tag>().find("Mouse") == cache.template get<name_tag>().end()));
+    
+    std::cout << "test_lru_products correct" << std::endl;
+}
+}
+
+USERVER_NAMESPACE_END