diff --git a/src/main/java/com/example/tampopotest/controller/ActivityController.java b/src/main/java/com/example/tampopotest/controller/ActivityController.java
new file mode 100644
index 0000000..cb46b76
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/ActivityController.java
@@ -0,0 +1,246 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.entity.Activity;
+import com.example.tampopotest.entity.User;
+import com.example.tampopotest.repository.ActivityRepository;
+import com.example.tampopotest.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/users/{user-id}/activities")
+public class ActivityController {
+    
+    @Autowired
+    private ActivityRepository activityRepository;
+    
+    @Autowired
+    private UserRepository userRepository;
+    
+    // GET /users/{user-id}/activities - アクティビティ一覧を返す
+    @GetMapping
+    public ResponseEntity<?> getActivities(@PathVariable("user-id") String userId) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            List<Activity> activities = activityRepository.findByUserId(userId);
+            List<Map<String, Object>> response = activities.stream()
+                    .map(activity -> {
+                        Map<String, Object> activityMap = new HashMap<>();
+                        activityMap.put("activity-id", activity.getActivityId());
+                        activityMap.put("text", activity.getText());
+                        activityMap.put("updated-time", activity.getUpdatedTime() != null ? 
+                                activity.getUpdatedTime().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME) : null);
+                        return activityMap;
+                    })
+                    .collect(Collectors.toList());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // POST /users/{user-id}/activities - アクティビティの作成
+    @PostMapping(consumes = "application/x-www-form-urlencoded")
+    public ResponseEntity<?> createActivity(@PathVariable("user-id") String userId,
+                                            @RequestParam("token") String token,
+                                            @RequestParam("activity-id") String activityId) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            User user = userOpt.get();
+            if (user.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!user.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            Activity activity = new Activity(activityId, userId);
+            activityRepository.save(activity);
+            
+            Map<String, Object> response = new HashMap<>();
+            response.put("activity-id", activity.getActivityId());
+            response.put("text", activity.getText());
+            response.put("updated-time", activity.getUpdatedTime() != null ? 
+                    activity.getUpdatedTime().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME) : null);
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /users/{user-id}/activities/{activity-id} - 単一アクティビティを返す
+    @GetMapping("/{activity-id}")
+    public ResponseEntity<?> getActivity(@PathVariable("user-id") String userId,
+                                         @PathVariable("activity-id") String activityId) {
+        try {
+            Optional<Activity> activityOpt = activityRepository.findByUserIdAndActivityId(userId, activityId);
+            if (activityOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            Activity activity = activityOpt.get();
+            Map<String, Object> response = new HashMap<>();
+            response.put("activity-id", activity.getActivityId());
+            response.put("text", activity.getText());
+            response.put("updated-time", activity.getUpdatedTime() != null ? 
+                    activity.getUpdatedTime().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME) : null);
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // DELETE /users/{user-id}/activities/{activity-id} - アクティビティの削除
+    @DeleteMapping("/{activity-id}")
+    @Transactional
+    public ResponseEntity<?> deleteActivity(@PathVariable("user-id") String userId,
+                                            @PathVariable("activity-id") String activityId,
+                                            @RequestParam("token") String token) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            User user = userOpt.get();
+            if (user.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!user.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            Optional<Activity> activityOpt = activityRepository.findByUserIdAndActivityId(userId, activityId);
+            if (activityOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            activityRepository.deleteByUserIdAndActivityId(userId, activityId);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /users/{user-id}/activities/{activity-id}/text - アクティビティのテキスト取得
+    @GetMapping("/{activity-id}/text")
+    public ResponseEntity<?> getActivityText(@PathVariable("user-id") String userId,
+                                             @PathVariable("activity-id") String activityId) {
+        try {
+            Optional<Activity> activityOpt = activityRepository.findByUserIdAndActivityId(userId, activityId);
+            if (activityOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            return ResponseEntity.ok(activityOpt.get().getText());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // PUT /users/{user-id}/activities/{activity-id}/text - アクティビティのテキスト更新
+    @PutMapping(value = "/{activity-id}/text", consumes = "application/x-www-form-urlencoded")
+    public ResponseEntity<?> updateActivityText(@PathVariable("user-id") String userId,
+                                                @PathVariable("activity-id") String activityId,
+                                                @RequestParam("token") String token,
+                                                @RequestParam("new-text") String newText) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            User user = userOpt.get();
+            if (user.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!user.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            Optional<Activity> activityOpt = activityRepository.findByUserIdAndActivityId(userId, activityId);
+            if (activityOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            Activity activity = activityOpt.get();
+            activity.setText(newText);
+            activity.setUpdatedTime(LocalDateTime.now());
+            activityRepository.save(activity);
+            
+            return ResponseEntity.ok(activity.getText());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /users/{user-id}/activities/{activity-id}/updated-time - アクティビティの更新時刻取得
+    @GetMapping("/{activity-id}/updated-time")
+    public ResponseEntity<?> getActivityUpdatedTime(@PathVariable("user-id") String userId,
+                                                    @PathVariable("activity-id") String activityId) {
+        try {
+            Optional<Activity> activityOpt = activityRepository.findByUserIdAndActivityId(userId, activityId);
+            if (activityOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            Activity activity = activityOpt.get();
+            String updatedTime = activity.getUpdatedTime() != null ? 
+                    activity.getUpdatedTime().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME) : null;
+            
+            return ResponseEntity.ok(updatedTime);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /users/{user-id}/activities/last-updated-time - 最終更新時刻取得
+    @GetMapping("/last-updated-time")
+    public ResponseEntity<?> getLastUpdatedTime(@PathVariable("user-id") String userId) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            List<Activity> activities = activityRepository.findByUserId(userId);
+            if (activities.isEmpty()) {
+                return ResponseEntity.ok(null);
+            }
+            
+            Optional<LocalDateTime> lastUpdated = activities.stream()
+                    .map(Activity::getUpdatedTime)
+                    .filter(Objects::nonNull)
+                    .max(LocalDateTime::compareTo);
+            
+            String result = lastUpdated.map(time -> time.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME))
+                    .orElse(null);
+            
+            return ResponseEntity.ok(result);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/controller/ChatRequestController.java b/src/main/java/com/example/tampopotest/controller/ChatRequestController.java
new file mode 100644
index 0000000..9a8a4d5
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/ChatRequestController.java
@@ -0,0 +1,160 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.entity.ChatRequest;
+import com.example.tampopotest.entity.ChatRoom;
+import com.example.tampopotest.entity.User;
+import com.example.tampopotest.repository.ChatRequestRepository;
+import com.example.tampopotest.repository.ChatRoomRepository;
+import com.example.tampopotest.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/chat-requests")
+public class ChatRequestController {
+    
+    @Autowired
+    private ChatRequestRepository chatRequestRepository;
+    
+    @Autowired
+    private UserRepository userRepository;
+    
+    @Autowired
+    private ChatRoomRepository chatRoomRepository;
+    
+    // GET /chat-requests/ - チャットリクエスト一覧を返す
+    @GetMapping
+    public ResponseEntity<?> getAllChatRequests() {
+        try {
+            List<ChatRequest> requests = chatRequestRepository.findAll();
+            if (requests.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            List<Map<String, Object>> response = requests.stream()
+                    .map(request -> {
+                        Map<String, Object> requestMap = new HashMap<>();
+                        requestMap.put("chat-request-id", request.getChatRequestId());
+                        requestMap.put("from-user-id", request.getFromUserId());
+                        requestMap.put("to-user-id", request.getToUserId());
+                        return requestMap;
+                    })
+                    .collect(Collectors.toList());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // POST /chat-requests/ - チャットリクエストの作成
+    @PostMapping(consumes = "application/x-www-form-urlencoded")
+    public ResponseEntity<?> createChatRequest(@RequestParam("token") String token,
+                                               @RequestParam("chat-request-id") String chatRequestId,
+                                               @RequestParam("from-user-id") String fromUserId,
+                                               @RequestParam("to-user-id") String toUserId) {
+        try {
+            Optional<User> fromUserOpt = userRepository.findByUserId(fromUserId);
+            if (fromUserOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("送信元ユーザーが存在しません");
+            }
+            
+            Optional<User> toUserOpt = userRepository.findByUserId(toUserId);
+            if (toUserOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("送信先ユーザーが存在しません");
+            }
+            
+            User fromUser = fromUserOpt.get();
+            if (fromUser.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!fromUser.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            ChatRequest request = new ChatRequest(chatRequestId, fromUserId, toUserId);
+            chatRequestRepository.save(request);
+            
+            Map<String, Object> response = new HashMap<>();
+            response.put("chat-request-id", request.getChatRequestId());
+            response.put("from-user-id", request.getFromUserId());
+            response.put("to-user-id", request.getToUserId());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /chat-requests/{chat-request-id}/ - 特定のチャットリクエスト情報を返す
+    @GetMapping("/{chat-request-id}")
+    public ResponseEntity<?> getChatRequest(@PathVariable("chat-request-id") String chatRequestId) {
+        try {
+            Optional<ChatRequest> requestOpt = chatRequestRepository.findByChatRequestId(chatRequestId);
+            if (requestOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            ChatRequest request = requestOpt.get();
+            Map<String, Object> response = new HashMap<>();
+            response.put("chat-request-id", request.getChatRequestId());
+            response.put("from-user-id", request.getFromUserId());
+            response.put("to-user-id", request.getToUserId());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // DELETE /chat-requests/{chat-request-id}/ - チャットリクエストの削除または承認
+    @DeleteMapping("/{chat-request-id}")
+    public ResponseEntity<?> deleteChatRequest(@PathVariable("chat-request-id") String chatRequestId,
+                                               @RequestParam("token") String token,
+                                               @RequestParam(value = "accept", required = false, defaultValue = "false") String accept) {
+        try {
+            Optional<ChatRequest> requestOpt = chatRequestRepository.findByChatRequestId(chatRequestId);
+            if (requestOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            ChatRequest request = requestOpt.get();
+            
+            // toUserのトークンで認証
+            Optional<User> toUserOpt = userRepository.findByUserId(request.getToUserId());
+            if (toUserOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("ユーザーが存在しません");
+            }
+            
+            User toUser = toUserOpt.get();
+            if (toUser.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!toUser.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            // acceptがtrueの場合、チャットルームを作成
+            if ("true".equalsIgnoreCase(accept)) {
+                String chatroomId = UUID.randomUUID().toString();
+                ChatRoom chatRoom = new ChatRoom(chatroomId);
+                chatRoom.getUserIds().add(request.getFromUserId());
+                chatRoom.getUserIds().add(request.getToUserId());
+                chatRoomRepository.save(chatRoom);
+            }
+            
+            // リクエストを削除
+            chatRequestRepository.delete(request);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/controller/ChatRoomController.java b/src/main/java/com/example/tampopotest/controller/ChatRoomController.java
new file mode 100644
index 0000000..844ebdc
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/ChatRoomController.java
@@ -0,0 +1,217 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.entity.ChatRoom;
+import com.example.tampopotest.entity.Message;
+import com.example.tampopotest.entity.User;
+import com.example.tampopotest.repository.ChatRoomRepository;
+import com.example.tampopotest.repository.MessageRepository;
+import com.example.tampopotest.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/chat-rooms")
+public class ChatRoomController {
+    
+    @Autowired
+    private ChatRoomRepository chatRoomRepository;
+    
+    @Autowired
+    private UserRepository userRepository;
+    
+    @Autowired
+    private MessageRepository messageRepository;
+    
+    // GET /chat-rooms/ - チャットルーム一覧を返す
+    @GetMapping
+    public ResponseEntity<?> getAllChatRooms() {
+        try {
+            List<ChatRoom> chatRooms = chatRoomRepository.findAll();
+            if (chatRooms.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            List<Map<String, Object>> response = chatRooms.stream()
+                    .map(room -> {
+                        Map<String, Object> roomMap = new HashMap<>();
+                        roomMap.put("chatroom-id", room.getChatroomId());
+                        roomMap.put("user-ids", room.getUserIds());
+                        return roomMap;
+                    })
+                    .collect(Collectors.toList());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // POST /chat-rooms/ - チャットルームの作成
+    @PostMapping(consumes = "application/x-www-form-urlencoded")
+    public ResponseEntity<?> createChatRoom(@RequestParam("token") String token,
+                                            @RequestParam("chatroom-id") String chatroomId,
+                                            @RequestParam("user-ids") String userIds) {
+        try {
+            // user-idsはカンマ区切りの文字列と仮定
+            List<String> userIdList = Arrays.asList(userIds.split(","));
+            
+            // トークンの検証 - user-idsに含まれるいずれかのユーザーのトークンであればOK
+            boolean validToken = false;
+            for (String userId : userIdList) {
+                Optional<User> userOpt = userRepository.findByUserId(userId.trim());
+                if (userOpt.isPresent() && userOpt.get().getToken() != null && 
+                    userOpt.get().getToken().equals(token)) {
+                    validToken = true;
+                    break;
+                }
+            }
+            
+            if (!validToken) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            ChatRoom chatRoom = new ChatRoom(chatroomId);
+            chatRoom.setUserIds(userIdList.stream().map(String::trim).collect(Collectors.toList()));
+            chatRoomRepository.save(chatRoom);
+            
+            Map<String, Object> response = new HashMap<>();
+            response.put("chatroom-id", chatRoom.getChatroomId());
+            response.put("user-ids", chatRoom.getUserIds());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /chat-rooms/{chatroom-id}/{user-id}/ - チャットルーム情報を返す
+    @GetMapping("/{chatroom-id}/{user-id}")
+    public ResponseEntity<?> getChatRoom(@PathVariable("chatroom-id") String chatroomId,
+                                         @PathVariable("user-id") String userId) {
+        try {
+            Optional<ChatRoom> roomOpt = chatRoomRepository.findByChatroomId(chatroomId);
+            if (roomOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            ChatRoom room = roomOpt.get();
+            if (!room.getUserIds().contains(userId)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("アクセス権限がありません");
+            }
+            
+            List<Message> messages = messageRepository.findByChatroomIdOrderByTimestampAsc(chatroomId);
+            List<Map<String, Object>> messageList = messages.stream()
+                    .map(message -> {
+                        Map<String, Object> msgMap = new HashMap<>();
+                        msgMap.put("user-id", message.getUserId());
+                        msgMap.put("text", message.getText());
+                        msgMap.put("timestamp", message.getTimestamp() != null ? 
+                                message.getTimestamp().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME) : null);
+                        return msgMap;
+                    })
+                    .collect(Collectors.toList());
+            
+            Map<String, Object> response = new HashMap<>();
+            response.put("chatroom-id", room.getChatroomId());
+            response.put("user-ids", room.getUserIds());
+            response.put("messages", messageList);
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // DELETE /chat-rooms/{chatroom-id}/{user-id}/ - チャットルームの削除
+    @DeleteMapping("/{chatroom-id}/{user-id}")
+    public ResponseEntity<?> deleteChatRoom(@PathVariable("chatroom-id") String chatroomId,
+                                            @PathVariable("user-id") String userId,
+                                            @RequestParam("token") String token) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("ユーザーが存在しません");
+            }
+            
+            User user = userOpt.get();
+            if (user.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!user.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            Optional<ChatRoom> roomOpt = chatRoomRepository.findByChatroomId(chatroomId);
+            if (roomOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            ChatRoom room = roomOpt.get();
+            if (!room.getUserIds().contains(userId)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("アクセス権限がありません");
+            }
+            
+            // メッセージも削除
+            List<Message> messages = messageRepository.findByChatroomIdOrderByTimestampAsc(chatroomId);
+            messageRepository.deleteAll(messages);
+            
+            chatRoomRepository.delete(room);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // POST /chat-rooms/{chatroom-id}/{user-id}/message - メッセージの送信
+    @PostMapping(value = "/{chatroom-id}/{user-id}/message", consumes = "application/x-www-form-urlencoded")
+    public ResponseEntity<?> sendMessage(@PathVariable("chatroom-id") String chatroomId,
+                                         @PathVariable("user-id") String userId,
+                                         @RequestParam("token") String token,
+                                         @RequestParam("text") String text) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("ユーザーが存在しません");
+            }
+            
+            User user = userOpt.get();
+            if (user.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!user.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            Optional<ChatRoom> roomOpt = chatRoomRepository.findByChatroomId(chatroomId);
+            if (roomOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            ChatRoom room = roomOpt.get();
+            if (!room.getUserIds().contains(userId)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("アクセス権限がありません");
+            }
+            
+            Message message = new Message(chatroomId, userId, text);
+            messageRepository.save(message);
+            
+            Map<String, Object> response = new HashMap<>();
+            response.put("user-id", message.getUserId());
+            response.put("text", message.getText());
+            response.put("timestamp", message.getTimestamp() != null ? 
+                    message.getTimestamp().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME) : null);
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/controller/FriendController.java b/src/main/java/com/example/tampopotest/controller/FriendController.java
new file mode 100644
index 0000000..0d24a41
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/FriendController.java
@@ -0,0 +1,238 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.entity.FriendPair;
+import com.example.tampopotest.entity.User;
+import com.example.tampopotest.repository.FriendPairRepository;
+import com.example.tampopotest.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@RestController
+public class FriendController {
+    
+    @Autowired
+    private FriendPairRepository friendPairRepository;
+    
+    @Autowired
+    private UserRepository userRepository;
+    
+    // GET /users/{user-id}/friends - フレンド一覧を返す
+    @GetMapping("/users/{user-id}/friends")
+    public ResponseEntity<?> getFriends(@PathVariable("user-id") String userId) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            List<FriendPair> friendPairs = friendPairRepository.findByUserId(userId);
+            List<Map<String, Object>> response = friendPairs.stream()
+                    .map(pair -> {
+                        Map<String, Object> pairMap = new HashMap<>();
+                        pairMap.put("pair-id", pair.getPairId());
+                        String friendId = pair.getUserId1().equals(userId) ? pair.getUserId2() : pair.getUserId1();
+                        pairMap.put("friend-id", friendId);
+                        return pairMap;
+                    })
+                    .collect(Collectors.toList());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /users/{user-id}/friends/{pair-id} - 特定のフレンドペア情報を返す
+    @GetMapping("/users/{user-id}/friends/{pair-id}")
+    public ResponseEntity<?> getFriendPair(@PathVariable("user-id") String userId,
+                                           @PathVariable("pair-id") String pairId) {
+        try {
+            Optional<FriendPair> pairOpt = friendPairRepository.findByPairId(pairId);
+            if (pairOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            FriendPair pair = pairOpt.get();
+            if (!pair.getUserId1().equals(userId) && !pair.getUserId2().equals(userId)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("アクセス権限がありません");
+            }
+            
+            Map<String, Object> response = new HashMap<>();
+            response.put("pair-id", pair.getPairId());
+            response.put("user-id1", pair.getUserId1());
+            response.put("user-id2", pair.getUserId2());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // DELETE /users/{user-id}/friends/{pair-id} - フレンド関係の削除
+    @DeleteMapping("/users/{user-id}/friends/{pair-id}")
+    public ResponseEntity<?> deleteFriendPair(@PathVariable("user-id") String userId,
+                                              @PathVariable("pair-id") String pairId,
+                                              @RequestParam("token") String token) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            User user = userOpt.get();
+            if (user.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!user.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            Optional<FriendPair> pairOpt = friendPairRepository.findByPairId(pairId);
+            if (pairOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            FriendPair pair = pairOpt.get();
+            if (!pair.getUserId1().equals(userId) && !pair.getUserId2().equals(userId)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("アクセス権限がありません");
+            }
+            
+            // ユーザーのfriendPairsリストから削除
+            User user1 = userRepository.findByUserId(pair.getUserId1()).orElse(null);
+            User user2 = userRepository.findByUserId(pair.getUserId2()).orElse(null);
+            
+            if (user1 != null) {
+                user1.getFriendPairs().remove(pairId);
+                userRepository.save(user1);
+            }
+            
+            if (user2 != null) {
+                user2.getFriendPairs().remove(pairId);
+                userRepository.save(user2);
+            }
+            
+            friendPairRepository.delete(pair);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /friends/ - 全フレンドペア一覧を返す
+    @GetMapping("/friends")
+    public ResponseEntity<?> getAllFriendPairs() {
+        try {
+            List<FriendPair> pairs = friendPairRepository.findAll();
+            if (pairs.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            List<Map<String, Object>> response = pairs.stream()
+                    .map(pair -> {
+                        Map<String, Object> pairMap = new HashMap<>();
+                        pairMap.put("pair-id", pair.getPairId());
+                        pairMap.put("user-id1", pair.getUserId1());
+                        pairMap.put("user-id2", pair.getUserId2());
+                        return pairMap;
+                    })
+                    .collect(Collectors.toList());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /friends/pairs/{pair-id}/ - 特定のペア情報を返す
+    @GetMapping("/friends/pairs/{pair-id}")
+    public ResponseEntity<?> getFriendPairById(@PathVariable("pair-id") String pairId) {
+        try {
+            Optional<FriendPair> pairOpt = friendPairRepository.findByPairId(pairId);
+            if (pairOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            FriendPair pair = pairOpt.get();
+            Map<String, Object> response = new HashMap<>();
+            response.put("pair-id", pair.getPairId());
+            response.put("user-id1", pair.getUserId1());
+            response.put("user-id2", pair.getUserId2());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // DELETE /friends/pairs/{pair-id}/ - ペアの削除
+    @DeleteMapping("/friends/pairs/{pair-id}")
+    public ResponseEntity<?> deleteFriendPairById(@PathVariable("pair-id") String pairId,
+                                                  @RequestParam("token") String token) {
+        try {
+            Optional<FriendPair> pairOpt = friendPairRepository.findByPairId(pairId);
+            if (pairOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            FriendPair pair = pairOpt.get();
+            
+            // トークン検証 - どちらかのユーザーのトークンであればOK
+            User user1 = userRepository.findByUserId(pair.getUserId1()).orElse(null);
+            User user2 = userRepository.findByUserId(pair.getUserId2()).orElse(null);
+            
+            boolean validToken = false;
+            if (user1 != null && user1.getToken() != null && user1.getToken().equals(token)) {
+                validToken = true;
+            }
+            if (user2 != null && user2.getToken() != null && user2.getToken().equals(token)) {
+                validToken = true;
+            }
+            
+            if (!validToken) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            // ユーザーのfriendPairsリストから削除
+            if (user1 != null) {
+                user1.getFriendPairs().remove(pairId);
+                userRepository.save(user1);
+            }
+            
+            if (user2 != null) {
+                user2.getFriendPairs().remove(pairId);
+                userRepository.save(user2);
+            }
+            
+            friendPairRepository.delete(pair);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /friends/users/{user-id} - 特定ユーザーのフレンド一覧
+    @GetMapping("/friends/users/{user-id}")
+    public ResponseEntity<?> getFriendsByUserId(@PathVariable("user-id") String userId) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            List<FriendPair> friendPairs = friendPairRepository.findByUserId(userId);
+            List<String> friendIds = friendPairs.stream()
+                    .map(pair -> pair.getUserId1().equals(userId) ? pair.getUserId2() : pair.getUserId1())
+                    .collect(Collectors.toList());
+            
+            return ResponseEntity.ok(friendIds);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/controller/FriendRequestController.java b/src/main/java/com/example/tampopotest/controller/FriendRequestController.java
new file mode 100644
index 0000000..af114d3
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/FriendRequestController.java
@@ -0,0 +1,169 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.entity.FriendPair;
+import com.example.tampopotest.entity.FriendRequest;
+import com.example.tampopotest.entity.User;
+import com.example.tampopotest.repository.FriendPairRepository;
+import com.example.tampopotest.repository.FriendRequestRepository;
+import com.example.tampopotest.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/friend-requests")
+public class FriendRequestController {
+    
+    @Autowired
+    private FriendRequestRepository friendRequestRepository;
+    
+    @Autowired
+    private UserRepository userRepository;
+    
+    @Autowired
+    private FriendPairRepository friendPairRepository;
+    
+    // GET /friend-requests - フレンドリクエスト一覧を返す
+    @GetMapping
+    public ResponseEntity<?> getAllFriendRequests() {
+        try {
+            List<FriendRequest> requests = friendRequestRepository.findAll();
+            if (requests.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            List<Map<String, Object>> response = requests.stream()
+                    .map(request -> {
+                        Map<String, Object> requestMap = new HashMap<>();
+                        requestMap.put("friend-request-id", request.getFriendRequestId());
+                        requestMap.put("from-user-id", request.getFromUserId());
+                        requestMap.put("to-user-id", request.getToUserId());
+                        return requestMap;
+                    })
+                    .collect(Collectors.toList());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // POST /friend-requests - フレンドリクエストの作成
+    @PostMapping(consumes = "application/x-www-form-urlencoded")
+    public ResponseEntity<?> createFriendRequest(@RequestParam("token") String token,
+                                                 @RequestParam("friend-request-id") String friendRequestId,
+                                                 @RequestParam("from-user-id") String fromUserId,
+                                                 @RequestParam("to-user-id") String toUserId) {
+        try {
+            Optional<User> fromUserOpt = userRepository.findByUserId(fromUserId);
+            if (fromUserOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("送信元ユーザーが存在しません");
+            }
+            
+            Optional<User> toUserOpt = userRepository.findByUserId(toUserId);
+            if (toUserOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("送信先ユーザーが存在しません");
+            }
+            
+            User fromUser = fromUserOpt.get();
+            if (fromUser.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!fromUser.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            FriendRequest request = new FriendRequest(friendRequestId, fromUserId, toUserId);
+            friendRequestRepository.save(request);
+            
+            Map<String, Object> response = new HashMap<>();
+            response.put("friend-request-id", request.getFriendRequestId());
+            response.put("from-user-id", request.getFromUserId());
+            response.put("to-user-id", request.getToUserId());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /friend-requests/{friend-request-id} - 特定のフレンドリクエスト情報を返す
+    @GetMapping("/{friend-request-id}")
+    public ResponseEntity<?> getFriendRequest(@PathVariable("friend-request-id") String friendRequestId) {
+        try {
+            Optional<FriendRequest> requestOpt = friendRequestRepository.findByFriendRequestId(friendRequestId);
+            if (requestOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            FriendRequest request = requestOpt.get();
+            Map<String, Object> response = new HashMap<>();
+            response.put("friend-request-id", request.getFriendRequestId());
+            response.put("from-user-id", request.getFromUserId());
+            response.put("to-user-id", request.getToUserId());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // DELETE /friend-requests/{friend-request-id} - フレンドリクエストの削除または承認
+    @DeleteMapping("/{friend-request-id}")
+    public ResponseEntity<?> deleteFriendRequest(@PathVariable("friend-request-id") String friendRequestId,
+                                                 @RequestParam("token") String token,
+                                                 @RequestParam(value = "accept", required = false, defaultValue = "false") String accept) {
+        try {
+            Optional<FriendRequest> requestOpt = friendRequestRepository.findByFriendRequestId(friendRequestId);
+            if (requestOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            FriendRequest request = requestOpt.get();
+            
+            // toUserのトークンで認証
+            Optional<User> toUserOpt = userRepository.findByUserId(request.getToUserId());
+            if (toUserOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("ユーザーが存在しません");
+            }
+            
+            User toUser = toUserOpt.get();
+            if (toUser.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!toUser.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            // acceptがtrueの場合、フレンドペアを作成
+            if ("true".equalsIgnoreCase(accept)) {
+                String pairId = UUID.randomUUID().toString();
+                FriendPair pair = new FriendPair(pairId, request.getFromUserId(), request.getToUserId());
+                friendPairRepository.save(pair);
+                
+                // 両ユーザーのfriendPairsリストに追加
+                Optional<User> fromUserOpt = userRepository.findByUserId(request.getFromUserId());
+                if (fromUserOpt.isPresent()) {
+                    User fromUser = fromUserOpt.get();
+                    fromUser.getFriendPairs().add(pairId);
+                    userRepository.save(fromUser);
+                }
+                
+                toUser.getFriendPairs().add(pairId);
+                userRepository.save(toUser);
+            }
+            
+            // リクエストを削除
+            friendRequestRepository.delete(request);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/controller/UserController.java b/src/main/java/com/example/tampopotest/controller/UserController.java
new file mode 100644
index 0000000..0cb2d54
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/UserController.java
@@ -0,0 +1,303 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.entity.User;
+import com.example.tampopotest.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/users")
+public class UserController {
+    
+    @Autowired
+    private UserRepository userRepository;
+    
+    // GET /users - 全アカウント情報を返す
+    @GetMapping
+    public ResponseEntity<?> getAllUsers() {
+        try {
+            List<String> userIds = userRepository.findAll().stream()
+                    .map(User::getUserId)
+                    .collect(Collectors.toList());
+            if (userIds.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            return ResponseEntity.ok(userIds);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // POST /users - 新規アカウントを作る
+    @PostMapping(consumes = "application/x-www-form-urlencoded")
+    public ResponseEntity<?> createUser(@RequestParam("user-id") String userId,
+                                        @RequestParam("password") String password) {
+        try {
+            if (userId == null || password == null || userId.trim().isEmpty() || password.trim().isEmpty()) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            
+            if (userRepository.existsByUserId(userId)) {
+                return ResponseEntity.status(HttpStatus.CONFLICT).body("ユーザーIDの重複");
+            }
+            
+            User user = new User(userId, password);
+            userRepository.save(user);
+            
+            Map<String, Object> response = new HashMap<>();
+            response.put("user-id", user.getUserId());
+            response.put("name", user.getName());
+            response.put("password", user.getPassword());
+            response.put("email", user.getEmail());
+            response.put("icon", user.getIcon());
+            response.put("token", user.getToken());
+            response.put("frinedPairs", user.getFriendPairs());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /users/{user-id} - 単一アカウントの情報を返す
+    @GetMapping("/{user-id}")
+    public ResponseEntity<?> getUser(@PathVariable("user-id") String userId) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            User user = userOpt.get();
+            Map<String, Object> response = new HashMap<>();
+            response.put("name", user.getName());
+            response.put("icon", user.getIcon());
+            
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // DELETE /users/{user-id} - アカウントの削除
+    @DeleteMapping("/{user-id}")
+    public ResponseEntity<?> deleteUser(@PathVariable("user-id") String userId,
+                                        @RequestParam("token") String token) {
+        try {
+            if (token == null || token.trim().isEmpty()) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            User user = userOpt.get();
+            if (user.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!user.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            userRepository.delete(user);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // POST /users/{user-id}/login - アカウントのログイン処理
+    @PostMapping(value = "/{user-id}/login", consumes = "application/x-www-form-urlencoded")
+    public ResponseEntity<?> login(@PathVariable("user-id") String userId,
+                                   @RequestParam("password") String password) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("IDが存在しません");
+            }
+            
+            User user = userOpt.get();
+            if (!user.getPassword().equals(password)) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("パスワード間違い");
+            }
+            
+            // トークンを生成
+            String token = UUID.randomUUID().toString();
+            user.setToken(token);
+            userRepository.save(user);
+            
+            return ResponseEntity.ok(Collections.singletonList(token));
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /users/{user-id}/name - ニックネームの取得
+    @GetMapping("/{user-id}/name")
+    public ResponseEntity<?> getName(@PathVariable("user-id") String userId) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            return ResponseEntity.ok(userOpt.get().getName());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // PUT /users/{user-id}/name - ニックネームの変更
+    @PutMapping(value = "/{user-id}/name", consumes = "application/x-www-form-urlencoded")
+    public ResponseEntity<?> updateName(@PathVariable("user-id") String userId,
+                                        @RequestParam("token") String token,
+                                        @RequestParam("new-name") String newName) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            User user = userOpt.get();
+            if (user.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!user.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            user.setName(newName);
+            userRepository.save(user);
+            
+            return ResponseEntity.ok(user.getName());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // PUT /users/{user-id}/password - パスワードの変更
+    @PutMapping(value = "/{user-id}/password", consumes = "application/x-www-form-urlencoded")
+    public ResponseEntity<?> updatePassword(@PathVariable("user-id") String userId,
+                                            @RequestParam("token") String token,
+                                            @RequestParam("new-password") String newPassword) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            User user = userOpt.get();
+            if (user.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!user.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            user.setPassword(newPassword);
+            userRepository.save(user);
+            
+            return ResponseEntity.ok(user.getPassword());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /users/{user-id}/email - メールアドレスの取得
+    @GetMapping("/{user-id}/email")
+    public ResponseEntity<?> getEmail(@PathVariable("user-id") String userId) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            return ResponseEntity.ok(userOpt.get().getEmail());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // PUT /users/{user-id}/email - メールアドレスの変更
+    @PutMapping(value = "/{user-id}/email", consumes = "application/x-www-form-urlencoded")
+    public ResponseEntity<?> updateEmail(@PathVariable("user-id") String userId,
+                                         @RequestParam("token") String token,
+                                         @RequestParam("new-email") String newEmail) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            User user = userOpt.get();
+            if (user.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!user.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            user.setEmail(newEmail);
+            userRepository.save(user);
+            
+            return ResponseEntity.ok(user.getEmail());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // GET /users/{user-id}/icon - アイコンURLの取得
+    @GetMapping("/{user-id}/icon")
+    public ResponseEntity<?> getIcon(@PathVariable("user-id") String userId) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            return ResponseEntity.ok(userOpt.get().getIcon());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+    
+    // PUT /users/{user-id}/icon - アイコンURLの変更
+    @PutMapping(value = "/{user-id}/icon", consumes = "application/x-www-form-urlencoded")
+    public ResponseEntity<?> updateIcon(@PathVariable("user-id") String userId,
+                                        @RequestParam("token") String token,
+                                        @RequestParam("new-icon") String newIcon) {
+        try {
+            Optional<User> userOpt = userRepository.findByUserId(userId);
+            if (userOpt.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            
+            User user = userOpt.get();
+            if (user.getToken() == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            
+            if (!user.getToken().equals(token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            
+            user.setIcon(newIcon);
+            userRepository.save(user);
+            
+            return ResponseEntity.ok(user.getIcon());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/Activity.java b/src/main/java/com/example/tampopotest/entity/Activity.java
new file mode 100644
index 0000000..d6350cc
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/Activity.java
@@ -0,0 +1,64 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "activities")
+public class Activity {
+    
+    @Id
+    @Column(name = "activity_id", nullable = false)
+    private String activityId;
+    
+    @Column(name = "user_id", nullable = false)
+    private String userId;
+    
+    @Column(name = "text", columnDefinition = "TEXT")
+    private String text;
+    
+    @Column(name = "updated_time")
+    private LocalDateTime updatedTime;
+    
+    public Activity() {
+    }
+    
+    public Activity(String activityId, String userId) {
+        this.activityId = activityId;
+        this.userId = userId;
+        this.updatedTime = LocalDateTime.now();
+    }
+    
+    // Getters and Setters
+    public String getActivityId() {
+        return activityId;
+    }
+    
+    public void setActivityId(String activityId) {
+        this.activityId = activityId;
+    }
+    
+    public String getUserId() {
+        return userId;
+    }
+    
+    public void setUserId(String userId) {
+        this.userId = userId;
+    }
+    
+    public String getText() {
+        return text;
+    }
+    
+    public void setText(String text) {
+        this.text = text;
+    }
+    
+    public LocalDateTime getUpdatedTime() {
+        return updatedTime;
+    }
+    
+    public void setUpdatedTime(LocalDateTime updatedTime) {
+        this.updatedTime = updatedTime;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/ChatRequest.java b/src/main/java/com/example/tampopotest/entity/ChatRequest.java
new file mode 100644
index 0000000..2d80644
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/ChatRequest.java
@@ -0,0 +1,52 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "chat_requests")
+public class ChatRequest {
+    
+    @Id
+    @Column(name = "chat_request_id", nullable = false)
+    private String chatRequestId;
+    
+    @Column(name = "from_user_id", nullable = false)
+    private String fromUserId;
+    
+    @Column(name = "to_user_id", nullable = false)
+    private String toUserId;
+    
+    public ChatRequest() {
+    }
+    
+    public ChatRequest(String chatRequestId, String fromUserId, String toUserId) {
+        this.chatRequestId = chatRequestId;
+        this.fromUserId = fromUserId;
+        this.toUserId = toUserId;
+    }
+    
+    // Getters and Setters
+    public String getChatRequestId() {
+        return chatRequestId;
+    }
+    
+    public void setChatRequestId(String chatRequestId) {
+        this.chatRequestId = chatRequestId;
+    }
+    
+    public String getFromUserId() {
+        return fromUserId;
+    }
+    
+    public void setFromUserId(String fromUserId) {
+        this.fromUserId = fromUserId;
+    }
+    
+    public String getToUserId() {
+        return toUserId;
+    }
+    
+    public void setToUserId(String toUserId) {
+        this.toUserId = toUserId;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/ChatRoom.java b/src/main/java/com/example/tampopotest/entity/ChatRoom.java
new file mode 100644
index 0000000..1a295cb
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/ChatRoom.java
@@ -0,0 +1,43 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+@Table(name = "chat_rooms")
+public class ChatRoom {
+    
+    @Id
+    @Column(name = "chatroom_id", nullable = false)
+    private String chatroomId;
+    
+    @ElementCollection
+    @CollectionTable(name = "chatroom_users", joinColumns = @JoinColumn(name = "chatroom_id"))
+    @Column(name = "user_id")
+    private List<String> userIds = new ArrayList<>();
+    
+    public ChatRoom() {
+    }
+    
+    public ChatRoom(String chatroomId) {
+        this.chatroomId = chatroomId;
+    }
+    
+    // Getters and Setters
+    public String getChatroomId() {
+        return chatroomId;
+    }
+    
+    public void setChatroomId(String chatroomId) {
+        this.chatroomId = chatroomId;
+    }
+    
+    public List<String> getUserIds() {
+        return userIds;
+    }
+    
+    public void setUserIds(List<String> userIds) {
+        this.userIds = userIds;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/FriendPair.java b/src/main/java/com/example/tampopotest/entity/FriendPair.java
new file mode 100644
index 0000000..9e4ac89
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/FriendPair.java
@@ -0,0 +1,52 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "friend_pairs")
+public class FriendPair {
+    
+    @Id
+    @Column(name = "pair_id", nullable = false)
+    private String pairId;
+    
+    @Column(name = "user_id1", nullable = false)
+    private String userId1;
+    
+    @Column(name = "user_id2", nullable = false)
+    private String userId2;
+    
+    public FriendPair() {
+    }
+    
+    public FriendPair(String pairId, String userId1, String userId2) {
+        this.pairId = pairId;
+        this.userId1 = userId1;
+        this.userId2 = userId2;
+    }
+    
+    // Getters and Setters
+    public String getPairId() {
+        return pairId;
+    }
+    
+    public void setPairId(String pairId) {
+        this.pairId = pairId;
+    }
+    
+    public String getUserId1() {
+        return userId1;
+    }
+    
+    public void setUserId1(String userId1) {
+        this.userId1 = userId1;
+    }
+    
+    public String getUserId2() {
+        return userId2;
+    }
+    
+    public void setUserId2(String userId2) {
+        this.userId2 = userId2;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/FriendRequest.java b/src/main/java/com/example/tampopotest/entity/FriendRequest.java
new file mode 100644
index 0000000..33ebba9
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/FriendRequest.java
@@ -0,0 +1,52 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "friend_requests")
+public class FriendRequest {
+    
+    @Id
+    @Column(name = "friend_request_id", nullable = false)
+    private String friendRequestId;
+    
+    @Column(name = "from_user_id", nullable = false)
+    private String fromUserId;
+    
+    @Column(name = "to_user_id", nullable = false)
+    private String toUserId;
+    
+    public FriendRequest() {
+    }
+    
+    public FriendRequest(String friendRequestId, String fromUserId, String toUserId) {
+        this.friendRequestId = friendRequestId;
+        this.fromUserId = fromUserId;
+        this.toUserId = toUserId;
+    }
+    
+    // Getters and Setters
+    public String getFriendRequestId() {
+        return friendRequestId;
+    }
+    
+    public void setFriendRequestId(String friendRequestId) {
+        this.friendRequestId = friendRequestId;
+    }
+    
+    public String getFromUserId() {
+        return fromUserId;
+    }
+    
+    public void setFromUserId(String fromUserId) {
+        this.fromUserId = fromUserId;
+    }
+    
+    public String getToUserId() {
+        return toUserId;
+    }
+    
+    public void setToUserId(String toUserId) {
+        this.toUserId = toUserId;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/Message.java b/src/main/java/com/example/tampopotest/entity/Message.java
new file mode 100644
index 0000000..9b8877f
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/Message.java
@@ -0,0 +1,77 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "messages")
+public class Message {
+    
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "message_id")
+    private Long messageId;
+    
+    @Column(name = "chatroom_id", nullable = false)
+    private String chatroomId;
+    
+    @Column(name = "user_id", nullable = false)
+    private String userId;
+    
+    @Column(name = "text", columnDefinition = "TEXT")
+    private String text;
+    
+    @Column(name = "timestamp")
+    private LocalDateTime timestamp;
+    
+    public Message() {
+    }
+    
+    public Message(String chatroomId, String userId, String text) {
+        this.chatroomId = chatroomId;
+        this.userId = userId;
+        this.text = text;
+        this.timestamp = LocalDateTime.now();
+    }
+    
+    // Getters and Setters
+    public Long getMessageId() {
+        return messageId;
+    }
+    
+    public void setMessageId(Long messageId) {
+        this.messageId = messageId;
+    }
+    
+    public String getChatroomId() {
+        return chatroomId;
+    }
+    
+    public void setChatroomId(String chatroomId) {
+        this.chatroomId = chatroomId;
+    }
+    
+    public String getUserId() {
+        return userId;
+    }
+    
+    public void setUserId(String userId) {
+        this.userId = userId;
+    }
+    
+    public String getText() {
+        return text;
+    }
+    
+    public void setText(String text) {
+        this.text = text;
+    }
+    
+    public LocalDateTime getTimestamp() {
+        return timestamp;
+    }
+    
+    public void setTimestamp(LocalDateTime timestamp) {
+        this.timestamp = timestamp;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/User.java b/src/main/java/com/example/tampopotest/entity/User.java
new file mode 100644
index 0000000..e3f1324
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/User.java
@@ -0,0 +1,99 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+@Table(name = "users")
+public class User {
+    
+    @Id
+    @Column(name = "user_id", nullable = false, unique = true)
+    private String userId;
+    
+    @Column(name = "name")
+    private String name;
+    
+    @Column(name = "password", nullable = false)
+    private String password;
+    
+    @Column(name = "email")
+    private String email;
+    
+    @Column(name = "icon")
+    private String icon;
+    
+    @Column(name = "token")
+    private String token;
+    
+    @ElementCollection
+    @CollectionTable(name = "user_friend_pairs", joinColumns = @JoinColumn(name = "user_id"))
+    @Column(name = "pair_id")
+    private List<String> friendPairs = new ArrayList<>();
+    
+    public User() {
+    }
+    
+    public User(String userId, String password) {
+        this.userId = userId;
+        this.password = password;
+    }
+    
+    // Getters and Setters
+    public String getUserId() {
+        return userId;
+    }
+    
+    public void setUserId(String userId) {
+        this.userId = userId;
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+    
+    public String getPassword() {
+        return password;
+    }
+    
+    public void setPassword(String password) {
+        this.password = password;
+    }
+    
+    public String getEmail() {
+        return email;
+    }
+    
+    public void setEmail(String email) {
+        this.email = email;
+    }
+    
+    public String getIcon() {
+        return icon;
+    }
+    
+    public void setIcon(String icon) {
+        this.icon = icon;
+    }
+    
+    public String getToken() {
+        return token;
+    }
+    
+    public void setToken(String token) {
+        this.token = token;
+    }
+    
+    public List<String> getFriendPairs() {
+        return friendPairs;
+    }
+    
+    public void setFriendPairs(List<String> friendPairs) {
+        this.friendPairs = friendPairs;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/repository/ActivityRepository.java b/src/main/java/com/example/tampopotest/repository/ActivityRepository.java
new file mode 100644
index 0000000..6538780
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/ActivityRepository.java
@@ -0,0 +1,18 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.Activity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface ActivityRepository extends JpaRepository<Activity, String> {
+    
+    List<Activity> findByUserId(String userId);
+    
+    Optional<Activity> findByUserIdAndActivityId(String userId, String activityId);
+    
+    void deleteByUserIdAndActivityId(String userId, String activityId);
+}
diff --git a/src/main/java/com/example/tampopotest/repository/ChatRequestRepository.java b/src/main/java/com/example/tampopotest/repository/ChatRequestRepository.java
new file mode 100644
index 0000000..00a3439
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/ChatRequestRepository.java
@@ -0,0 +1,18 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.ChatRequest;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface ChatRequestRepository extends JpaRepository<ChatRequest, String> {
+    
+    Optional<ChatRequest> findByChatRequestId(String chatRequestId);
+    
+    List<ChatRequest> findByToUserId(String toUserId);
+    
+    List<ChatRequest> findByFromUserId(String fromUserId);
+}
diff --git a/src/main/java/com/example/tampopotest/repository/ChatRoomRepository.java b/src/main/java/com/example/tampopotest/repository/ChatRoomRepository.java
new file mode 100644
index 0000000..f31e6b2
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/ChatRoomRepository.java
@@ -0,0 +1,13 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.ChatRoom;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface ChatRoomRepository extends JpaRepository<ChatRoom, String> {
+    
+    Optional<ChatRoom> findByChatroomId(String chatroomId);
+}
diff --git a/src/main/java/com/example/tampopotest/repository/FriendPairRepository.java b/src/main/java/com/example/tampopotest/repository/FriendPairRepository.java
new file mode 100644
index 0000000..a7c3b12
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/FriendPairRepository.java
@@ -0,0 +1,19 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.FriendPair;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface FriendPairRepository extends JpaRepository<FriendPair, String> {
+    
+    Optional<FriendPair> findByPairId(String pairId);
+    
+    @Query("SELECT f FROM FriendPair f WHERE f.userId1 = :userId OR f.userId2 = :userId")
+    List<FriendPair> findByUserId(@Param("userId") String userId);
+}
diff --git a/src/main/java/com/example/tampopotest/repository/FriendRequestRepository.java b/src/main/java/com/example/tampopotest/repository/FriendRequestRepository.java
new file mode 100644
index 0000000..bf7e078
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/FriendRequestRepository.java
@@ -0,0 +1,18 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.FriendRequest;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface FriendRequestRepository extends JpaRepository<FriendRequest, String> {
+    
+    Optional<FriendRequest> findByFriendRequestId(String friendRequestId);
+    
+    List<FriendRequest> findByToUserId(String toUserId);
+    
+    List<FriendRequest> findByFromUserId(String fromUserId);
+}
diff --git a/src/main/java/com/example/tampopotest/repository/MessageRepository.java b/src/main/java/com/example/tampopotest/repository/MessageRepository.java
new file mode 100644
index 0000000..060daaf
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/MessageRepository.java
@@ -0,0 +1,15 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.Message;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface MessageRepository extends JpaRepository<Message, Long> {
+    
+    List<Message> findByChatroomIdOrderByTimestampAsc(String chatroomId);
+    
+    List<Message> findByChatroomIdAndUserId(String chatroomId, String userId);
+}
diff --git a/src/main/java/com/example/tampopotest/repository/UserRepository.java b/src/main/java/com/example/tampopotest/repository/UserRepository.java
new file mode 100644
index 0000000..ada587c
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/UserRepository.java
@@ -0,0 +1,17 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, String> {
+    
+    Optional<User> findByUserId(String userId);
+    
+    boolean existsByUserId(String userId);
+    
+    Optional<User> findByToken(String token);
+}