diff --git a/src/main/java/com/whylog/server/domain/meeting/controller/MeetingController.java b/src/main/java/com/whylog/server/domain/meeting/controller/MeetingController.java
index 293c0cf..421a469 100644
--- a/src/main/java/com/whylog/server/domain/meeting/controller/MeetingController.java
+++ b/src/main/java/com/whylog/server/domain/meeting/controller/MeetingController.java
@@ -182,7 +182,14 @@ public ApiResponse<MeetingResponse.HistoryListDTO> getHistory(
     }
 
     @GetMapping("/meetings/{meetingId}/analysis")
-    @Operation(summary = "회의 분석 결과 조회 API", description = "회의 분석 결과를 조회하는 API입니다.")
+    @Operation(summary = "회의 분석 결과 조회 API", description = """
+            
+            회의 분석 결과를 조회하는 API입니다.<br>
+            회의가 존재하지 않으면 MEETING_NOT_FOUND(404)를 반환하고<br>
+            회의가 존재하지만 아직 분석 중이거나 분석 결과를 만들지 못 헀을 경우에는<br>
+            200응답으로 is_analyzed=false인 응답을 반환합니다.<br>
+            
+            """)
     @ApiErrorCodeExamples({
             @ApiErrorCodeExample(value = ErrorStatus.class, name = "_UNAUTHORIZED"),
             @ApiErrorCodeExample(value = ErrorStatus.class, name = "_BAD_REQUEST"),
@@ -190,19 +197,27 @@ public ApiResponse<MeetingResponse.HistoryListDTO> getHistory(
     })
     public ApiResponse<MeetingResponse.AnalysisResultDTO> getAnalysisResult(
             @PathVariable Long meetingId) {
-        return ApiResponse.onSuccess(null);
+        return ApiResponse.onSuccess(meetingQueryService.getAnalysis(meetingId));
     }
 
     @GetMapping("/meetings/{meetingId}/audio")
-    @Operation(summary = "오디오 리플레이 API", description = "회의 오디오 파일을 리플레이하는 API입니다.")
+    @Operation(summary = "오디오 리플레이 API", description = """
+            회의 녹음본을 브라우저에서 바로 재생할 수 있는 정보를 조회하는 API입니다.
+
+            응답의 `audioUrl`은 10분짜리 presigned URL입니다.
+            프론트는 이 값을 `<audio src>` 또는 `new Audio(audioUrl)`로 바로 사용할 수 있습니다.
+
+            `audioDuration`은 초 단위 재생 시간이며, 녹음본이 없거나 길이를 확인할 수 없으면 `null`입니다.
+            """)
     @ApiErrorCodeExamples({
             @ApiErrorCodeExample(value = ErrorStatus.class, name = "_UNAUTHORIZED"),
             @ApiErrorCodeExample(value = ErrorStatus.class, name = "_BAD_REQUEST"),
-            @ApiErrorCodeExample(value = MeetingErrorCode.class, name = "MEETING_NOT_FOUND")
+            @ApiErrorCodeExample(value = MeetingErrorCode.class, name = "MEETING_NOT_FOUND"),
+            @ApiErrorCodeExample(value = MeetingErrorCode.class, name = "MEETING_AUDIO_NOT_READY")
     })
     public ApiResponse<MeetingResponse.AudioDTO> getAudio(
             @PathVariable Long meetingId) {
-        return ApiResponse.onSuccess(null);
+        return ApiResponse.onSuccess(meetingQueryService.getMeetingAudio(meetingId));
     }
 
 //    @GetMapping("/meetings/{meetingId}/applications")
diff --git a/src/main/java/com/whylog/server/domain/meeting/dto/MeetingResponse.java b/src/main/java/com/whylog/server/domain/meeting/dto/MeetingResponse.java
index 4b7f528..d5d77e7 100644
--- a/src/main/java/com/whylog/server/domain/meeting/dto/MeetingResponse.java
+++ b/src/main/java/com/whylog/server/domain/meeting/dto/MeetingResponse.java
@@ -1,5 +1,6 @@
 package com.whylog.server.domain.meeting.dto;
 
+import com.whylog.server.domain.meeting.entity.MeetingAnalysis;
 import com.whylog.server.domain.meeting.enums.MeetingStatus;
 import com.whylog.server.domain.meeting.socket.MeetingParticipant;
 import io.swagger.v3.oas.annotations.media.Schema;
@@ -153,6 +154,13 @@ public static class MeetingDetailDTO {
 
         @Schema(description = "회의 참여자 목록", example = "[1, 2, 3]")
         private List<MeetingParticipantInfo> members;
+
+        @Schema(
+                description = "녹음 파일의 재생 시간(초). 녹음본이 아직 없거나 길이를 확인할 수 없으면 null 입니다.",
+                example = "120",
+                nullable = true
+        )
+        private Integer audioDuration;
     }
 
     @Getter
@@ -216,25 +224,78 @@ public static class AnalysisResultDTO {
         @Schema(description = "회의 ID", example = "1")
         private Long meetingId;
 
-        @Schema(description = "분석 내용", example = "뭐 이건 나중에 논의 주제, 핵심맥락 등 들어갈 자리입니다.")
-        private String content;
+        @Schema(description = "분석 완료 여부", example = "true")
+        private Boolean isAnalyzed;
+
+        @Schema(description = "회의 제목", example = "Whylog 프로젝트 서버 저장 및 배포 관련 논의", nullable = true)
+        private String meetingTitle;
+
+        @Schema(description = "회의 목적", example = "서버 저장 시도 및 배포 DB 상태 점검", nullable = true)
+        private String meetingPurpose;
+
+        @Schema(description = "회의 재생 시간(초)", example = "43", nullable = true)
+        private Integer audioDuration;
+
+        @Schema(description = "논의 주제 목록", example = "[\"서버 저장 상태 확인\", \"배포 DB 환경\"]", nullable = true)
+        private List<String> topics;
+
+        @Schema(description = "핵심 맥락 목록", example = "[\"서버에 데이터가 저장되지 않은 상태로 추정됨\"]", nullable = true)
+        private List<String> coreContext;
+
+        @Schema(description = "적용사항 제목 목록", example = "[\"서버 저장 절차 정리\", \"배포 DB 점검\"]", nullable = true)
+        private List<String> applicationTitles;
+
+        @Schema(description = "적용사항 사유 목록", example = "[\"저장 실패 원인을 추적하기 위해\", \"배포 환경 차이를 확인하기 위해\"]", nullable = true)
+        private List<String> applicationReasons;
+
+        public static AnalysisResultDTO createFalse(Long meetingId) {
+            return AnalysisResultDTO.builder()
+                    .meetingId(meetingId)
+                    .isAnalyzed(false)
+                    .build();
+        }
+
+        public static AnalysisResultDTO create(MeetingAnalysis ma, Integer audioDuration) {
+            return AnalysisResultDTO.builder()
+                    .analysisId(ma.getId())
+                    .meetingId(ma.getMeeting().getId())
+                    .isAnalyzed(true)
+                    .meetingTitle(ma.getMeetingTitle())
+                    .meetingPurpose(ma.getMeetingPurpose())
+                    .audioDuration(audioDuration)
+                    .topics(ma.getTopics())
+                    .coreContext(ma.getCoreContext())
+                    .applicationTitles(ma.getApplicationTitles())
+                    .applicationReasons(ma.getApplicationReasons())
+                    .build();
+        }
+
     }
 
     @Getter
     @NoArgsConstructor
     @AllArgsConstructor
     @Builder
-    @Schema(description = "회의 오디오 응답")
+    @Schema(description = "회의 오디오 응답. 프론트엔드는 audioUrl을 <audio src> 또는 Audio()로 바로 재생하면 됩니다.")
     public static class AudioDTO {
-
-        @Schema(description = "오디오 ID", example = "1")
-        private Long audioId;
-
         @Schema(description = "회의 ID", example = "1")
         private Long meetingId;
 
-        @Schema(description = "오디오 URL", example = "https://example.com/audio/meeting-1.mp3")
+        @Schema(description = "실제 재생 가능한 오디오 저장 키(S3 object key). 예: recordings/meeting-1-audio.mp4", example = "recordings/meeting-1-audio.mp4")
+        private String audioKey;
+
+        @Schema(
+                description = "10분짜리 presigned URL. 브라우저는 이 URL로 오디오를 직접 받아 재생합니다.",
+                example = "https://example.com/presigned-audio-url"
+        )
         private String audioUrl;
+
+        @Schema(
+                description = "녹음 파일의 재생 시간(초). 아직 파일이 없거나 길이를 알 수 없으면 null 입니다.",
+                example = "120",
+                nullable = true
+        )
+        private Integer audioDuration;
     }
 
     @Getter
diff --git a/src/main/java/com/whylog/server/domain/meeting/entity/Dialogue.java b/src/main/java/com/whylog/server/domain/meeting/entity/Dialogue.java
index 07ff777..6e3fc2f 100644
--- a/src/main/java/com/whylog/server/domain/meeting/entity/Dialogue.java
+++ b/src/main/java/com/whylog/server/domain/meeting/entity/Dialogue.java
@@ -40,4 +40,13 @@ public class Dialogue extends BaseEntity {
 
     @Column(name = "speech_datetime", nullable = false)
     private LocalDateTime speechDateTime;
+
+    public static Dialogue create(Meeting meeting, Member member, String content, LocalDateTime speechDateTime) {
+        Dialogue dialogue = new Dialogue();
+        dialogue.meeting = meeting;
+        dialogue.member = member;
+        dialogue.content = content;
+        dialogue.speechDateTime = speechDateTime;
+        return dialogue;
+    }
 }
diff --git a/src/main/java/com/whylog/server/domain/meeting/entity/Meeting.java b/src/main/java/com/whylog/server/domain/meeting/entity/Meeting.java
index 6cd9063..3d578fa 100644
--- a/src/main/java/com/whylog/server/domain/meeting/entity/Meeting.java
+++ b/src/main/java/com/whylog/server/domain/meeting/entity/Meeting.java
@@ -13,10 +13,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import lombok.AccessLevel;
-import lombok.Builder;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
+import lombok.*;
 
 @Entity
 @Getter
@@ -42,6 +39,14 @@ public class Meeting extends BaseEntity {
     @Column(name = "end_date_time")
     private LocalDateTime endDateTime;
 
+    @Setter
+    @Column(name = "audio_key", length = 255)
+    private String audioKey;
+
+    @Setter
+    @Column(name = "audio_egress_id", length = 100)
+    private String audioEgressId;
+
     @Builder
     private Meeting(String name, Team team) {
         this.name = name;
@@ -99,4 +104,12 @@ public String getElapse() {
 //
 //    @OneToOne(mappedBy = "meeting", cascade = CascadeType.ALL, orphanRemoval = true)
 //    private Decision decision;
+
+    public void attachMeetingAnalysis(MeetingAnalysis meetingAnalysis) {
+        this.meetingAnalysis = meetingAnalysis;
+    }
+
+    public void addDialogue(Dialogue dialogue) {
+        this.dialogues.add(dialogue);
+    }
 }
diff --git a/src/main/java/com/whylog/server/domain/meeting/entity/MeetingAnalysis.java b/src/main/java/com/whylog/server/domain/meeting/entity/MeetingAnalysis.java
index ce0100d..c535dc4 100644
--- a/src/main/java/com/whylog/server/domain/meeting/entity/MeetingAnalysis.java
+++ b/src/main/java/com/whylog/server/domain/meeting/entity/MeetingAnalysis.java
@@ -1,10 +1,12 @@
 package com.whylog.server.domain.meeting.entity;
 
 import com.whylog.server.global.entity.BaseEntity;
+import com.whylog.server.global.util.json.StringListJsonConverter;
 import jakarta.persistence.*;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
+import java.util.List;
 
 @Entity
 @Getter
@@ -20,4 +22,70 @@ public class MeetingAnalysis extends BaseEntity {
     @OneToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "meeting_id", nullable = false, unique = true)
     private Meeting meeting;
+
+    @Column(name = "meeting_title")
+    private String meetingTitle;
+
+    @Column(name = "meeting_purpose")
+    private String meetingPurpose;
+
+    @Column(name = "meeting_duration")
+    private String meetingDuration;
+
+    @Column(name = "analysis_content", columnDefinition = "LONGTEXT")
+    private String analysisContent;
+
+    @Convert(converter = StringListJsonConverter.class)
+    @Column(name = "topics", columnDefinition = "LONGTEXT")
+    private List<String> topics;
+
+    @Convert(converter = StringListJsonConverter.class)
+    @Column(name = "core_context", columnDefinition = "LONGTEXT")
+    private List<String> coreContext;
+
+    @Convert(converter = StringListJsonConverter.class)
+    @Column(name = "application_titles", columnDefinition = "LONGTEXT")
+    private List<String> applicationTitles;
+
+    @Convert(converter = StringListJsonConverter.class)
+    @Column(name = "application_reasons", columnDefinition = "LONGTEXT")
+    private List<String> applicationReasons;
+
+    public static MeetingAnalysis create(Meeting meeting, MeetingAnalysisPayload payload) {
+        MeetingAnalysis meetingAnalysis = new MeetingAnalysis();
+        meetingAnalysis.meeting = meeting;
+        meetingAnalysis.apply(payload);
+        return meetingAnalysis;
+    }
+
+    public void updateAnalysis(MeetingAnalysisPayload payload) {
+        apply(payload);
+    }
+
+    private void apply(MeetingAnalysisPayload payload) {
+        if (payload == null) {
+            return;
+        }
+
+        this.meetingTitle = payload.meetingTitle();
+        this.meetingPurpose = payload.meetingPurpose();
+        this.meetingDuration = payload.meetingDuration();
+        this.analysisContent = payload.analysisContent();
+        this.topics = payload.topics();
+        this.coreContext = payload.coreContext();
+        this.applicationTitles = payload.applicationTitles();
+        this.applicationReasons = payload.applicationReasons();
+    }
+
+    public record MeetingAnalysisPayload(
+            String meetingTitle,
+            String meetingPurpose,
+            String meetingDuration,
+            String analysisContent,
+            List<String> topics,
+            List<String> coreContext,
+            List<String> applicationTitles,
+            List<String> applicationReasons
+    ) {
+    }
 }
diff --git a/src/main/java/com/whylog/server/domain/meeting/exception/MeetingAudioNotReadyException.java b/src/main/java/com/whylog/server/domain/meeting/exception/MeetingAudioNotReadyException.java
new file mode 100644
index 0000000..0bca396
--- /dev/null
+++ b/src/main/java/com/whylog/server/domain/meeting/exception/MeetingAudioNotReadyException.java
@@ -0,0 +1,10 @@
+package com.whylog.server.domain.meeting.exception;
+
+import com.whylog.server.global.apiPayload.exception.GeneralException;
+
+public class MeetingAudioNotReadyException extends GeneralException {
+
+    public MeetingAudioNotReadyException() {
+        super(MeetingErrorCode.MEETING_AUDIO_NOT_READY);
+    }
+}
diff --git a/src/main/java/com/whylog/server/domain/meeting/exception/MeetingErrorCode.java b/src/main/java/com/whylog/server/domain/meeting/exception/MeetingErrorCode.java
index 77f2d32..3b1d0c5 100644
--- a/src/main/java/com/whylog/server/domain/meeting/exception/MeetingErrorCode.java
+++ b/src/main/java/com/whylog/server/domain/meeting/exception/MeetingErrorCode.java
@@ -14,6 +14,7 @@ public enum MeetingErrorCode implements BaseErrorCode {
     MEETING_ALREADY_ENDED(HttpStatus.CONFLICT, "MEETING_409", "이미 종료된 회의입니다."),
     MEETING_INVALID_MEMBER(HttpStatus.CONFLICT, "MEETING_410", "회의에 소속된 참여자가 아닙니다."),
     MEETING_NOT_OWNER(HttpStatus.FORBIDDEN, "MEETING_403", "회의 삭제 권한이 없습니다."),
+    MEETING_AUDIO_NOT_READY(HttpStatus.CONFLICT, "MEETING_411", "회의 녹음본이 아직 생성되지 않았거나 업로드가 완료되지 않았습니다."),
     ;
 
     private final HttpStatus httpStatus;
diff --git a/src/main/java/com/whylog/server/domain/meeting/repository/MeetingAnalysisRepository.java b/src/main/java/com/whylog/server/domain/meeting/repository/MeetingAnalysisRepository.java
index 3b3d6fc..6842bed 100644
--- a/src/main/java/com/whylog/server/domain/meeting/repository/MeetingAnalysisRepository.java
+++ b/src/main/java/com/whylog/server/domain/meeting/repository/MeetingAnalysisRepository.java
@@ -6,6 +6,8 @@
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 
+import java.util.Optional;
+
 public interface MeetingAnalysisRepository extends JpaRepository<MeetingAnalysis, Long> {
 
     @Modifying
@@ -15,4 +17,11 @@ public interface MeetingAnalysisRepository extends JpaRepository<MeetingAnalysis
     @Modifying
     @Query("DELETE FROM MeetingAnalysis ma WHERE ma.meeting.id = :meetingId")
     void deleteByMeetingId(@Param("meetingId") Long meetingId);
+
+    @Query("""
+        SELECT ma FROM MeetingAnalysis ma
+        LEFT JOIN FETCH ma.meeting m
+            WHERE m.id = :meetingId
+    """)
+    Optional<MeetingAnalysis> findByMeetingId(@Param("meetingId") Long meetingId);
 }
diff --git a/src/main/java/com/whylog/server/domain/meeting/repository/MeetingRepository.java b/src/main/java/com/whylog/server/domain/meeting/repository/MeetingRepository.java
index abf553d..6b2804f 100644
--- a/src/main/java/com/whylog/server/domain/meeting/repository/MeetingRepository.java
+++ b/src/main/java/com/whylog/server/domain/meeting/repository/MeetingRepository.java
@@ -21,7 +21,8 @@ public interface MeetingRepository extends JpaRepository<Meeting, Long> {
     @Query("""
         SELECT DISTINCT m
         FROM Meeting m
-        LEFT JOIN FETCH m.meetingMembers
+        LEFT JOIN FETCH m.meetingMembers mm
+        LEFT JOIN FETCH mm.member
         WHERE m.id = :meetingId
     """)
     Optional<Meeting> findWithMembers(@Param("meetingId") Long meetingId);
diff --git a/src/main/java/com/whylog/server/domain/meeting/service/LiveKitTokenService.java b/src/main/java/com/whylog/server/domain/meeting/service/LiveKitTokenService.java
new file mode 100644
index 0000000..7ca6706
--- /dev/null
+++ b/src/main/java/com/whylog/server/domain/meeting/service/LiveKitTokenService.java
@@ -0,0 +1,67 @@
+package com.whylog.server.domain.meeting.service;
+
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.security.Keys;
+import jakarta.validation.constraints.NotBlank;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import javax.crypto.SecretKey;
+import java.nio.charset.StandardCharsets;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+@Service
+public class LiveKitTokenService {
+
+    private final String liveKitApiKey;
+    private final String liveKitApiSecret;
+
+    public LiveKitTokenService(
+            @Value("${livekit.api-key}") @NotBlank String liveKitApiKey,
+            @Value("${livekit.api-secret}") @NotBlank String liveKitApiSecret
+    ) {
+        this.liveKitApiKey = liveKitApiKey;
+        this.liveKitApiSecret = liveKitApiSecret;
+    }
+
+    public String createJoinToken(String identity, String name, String roomName) {
+        Map<String, Object> videoGrant = new LinkedHashMap<>();
+        videoGrant.put("roomJoin", true);
+        videoGrant.put("room", roomName);
+        videoGrant.put("canPublish", true);
+        videoGrant.put("canSubscribe", true);
+        videoGrant.put("canPublishData", true);
+
+        return createToken(identity, name, videoGrant);
+    }
+
+    public String createRoomRecordToken(String identity, String roomName) {
+        Map<String, Object> videoGrant = new LinkedHashMap<>();
+        videoGrant.put("roomRecord", true);
+        videoGrant.put("room", roomName);
+
+        return createToken(identity, "recording-bot", videoGrant);
+    }
+
+    public String createRoomCreateToken(String identity) {
+        Map<String, Object> videoGrant = new LinkedHashMap<>();
+        videoGrant.put("roomCreate", true);
+
+        return createToken(identity, "room-admin", videoGrant);
+    }
+
+    private String createToken(String identity, String name, Map<String, Object> videoGrant) {
+        return Jwts.builder()
+                .setIssuer(liveKitApiKey)
+                .setSubject(identity)
+                .claim("name", name)
+                .claim("video", videoGrant)
+                .signWith(getSigningKey())
+                .compact();
+    }
+
+    private SecretKey getSigningKey() {
+        return Keys.hmacShaKeyFor(liveKitApiSecret.getBytes(StandardCharsets.UTF_8));
+    }
+}
diff --git a/src/main/java/com/whylog/server/domain/meeting/service/MeetingAnalysisService.java b/src/main/java/com/whylog/server/domain/meeting/service/MeetingAnalysisService.java
new file mode 100644
index 0000000..d93be18
--- /dev/null
+++ b/src/main/java/com/whylog/server/domain/meeting/service/MeetingAnalysisService.java
@@ -0,0 +1,384 @@
+package com.whylog.server.domain.meeting.service;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.whylog.server.domain.meeting.dto.MeetingResponse;
+import com.whylog.server.domain.meeting.entity.Dialogue;
+import com.whylog.server.domain.meeting.entity.Meeting;
+import com.whylog.server.domain.meeting.entity.MeetingAnalysis;
+import com.whylog.server.domain.meeting.entity.MeetingMember;
+import com.whylog.server.domain.meeting.exception.MeetingAudioNotReadyException;
+import com.whylog.server.domain.meeting.repository.DialogueRepository;
+import com.whylog.server.domain.meeting.repository.MeetingAnalysisRepository;
+import com.whylog.server.domain.user.entity.Member;
+import com.whylog.server.global.external.fast.client.FastApiTranscribeClient;
+import com.whylog.server.global.external.fast.dto.FastApiResponse;
+import com.whylog.server.global.external.fast.dto.response.TranscribeApplicationRunCreateResponse;
+import com.whylog.server.global.external.fast.dto.response.TranscribeApplicationRunResponse;
+import com.whylog.server.global.external.fast.exception.FastApiErrorCode;
+import com.whylog.server.global.external.fast.exception.FastApiException;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.core.io.UrlResource;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.support.TransactionTemplate;
+import org.springframework.web.client.HttpClientErrorException;
+import org.springframework.web.client.RestClientResponseException;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class MeetingAnalysisService {
+
+    private static final Duration AUDIO_READY_WAIT_INTERVAL = Duration.ofSeconds(3);
+    private static final int MAX_AUDIO_READY_ATTEMPTS = 20;
+    private static final Duration RUN_POLL_WAIT_INTERVAL = Duration.ofSeconds(3);
+    private static final int MAX_RUN_POLL_ATTEMPTS = 120;
+    private static final Pattern SPEAKER_INDEX_PATTERN = Pattern.compile("(\\d+)");
+
+    private final MeetingUseCase meetingUseCase;
+    private final MeetingAudioReplayService meetingAudioReplayService;
+    private final MeetingAudioFileService meetingAudioFileService;
+    private final FastApiTranscribeClient fastApiTranscribeClient;
+    private final MeetingAnalysisRepository meetingAnalysisRepository;
+    private final DialogueRepository dialogueRepository;
+    private final TransactionTemplate transactionTemplate;
+    private final ObjectMapper objectMapper;
+
+    // 회의 종료 후 오디오 분석 전체 흐름을 시작한다. ( 외부 클래스에서 호출 )
+    public void analyzeMeetingAudio(Long meetingId) {
+        Meeting meeting = meetingUseCase.findMeetingWithMembersById(meetingId);
+        MeetingResponse.AudioDTO audioResponse = resolveAudioWithRetry(meeting);
+
+        String runId = createTranscribeApplicationRun(meeting, audioResponse);
+        TranscribeApplicationRunResponse finalResponse = pollTranscribeApplicationRun(runId);
+        persistMeetingAnalysis(meeting, finalResponse);
+    }
+
+    // 회의 오디오가 준비될 때까지 재시도하며 오디오 응답을 확보한다.
+    private MeetingResponse.AudioDTO resolveAudioWithRetry(Meeting meeting) {
+        MeetingAudioNotReadyException lastException = null;
+
+        for (int attempt = 1; attempt <= MAX_AUDIO_READY_ATTEMPTS; attempt++) {
+            try {
+                return meetingAudioReplayService.buildAudioResponse(meeting);
+            } catch (MeetingAudioNotReadyException e) {
+                lastException = e;
+                sleep(AUDIO_READY_WAIT_INTERVAL);
+            }
+        }
+
+        if (lastException != null) {
+            throw lastException;
+        }
+        throw new MeetingAudioNotReadyException();
+    }
+
+    // FastAPI 전사용 비동기 실행(run)을 생성하고 runId를 반환한다.
+    private String createTranscribeApplicationRun(Meeting meeting, MeetingResponse.AudioDTO audioResponse) {
+        String audioKey = audioResponse.getAudioKey();
+        String audioUrl = audioResponse.getAudioUrl();
+        String audioFilename = meetingAudioFileService.extractFileName(audioKey);
+        String contentType = meetingAudioFileService.resolveResponseContentType(audioKey);
+
+        FastApiResponse<TranscribeApplicationRunCreateResponse> createResponse = fastApiTranscribeClient.createTranscribeApplicationRun(
+                buildAudioResource(audioUrl),
+                audioFilename,
+                contentType,
+                null,
+                String.valueOf(meeting.getId()),
+                null
+        );
+
+        String runId = requireResult(createResponse).runId();
+        log.info("회의 오디오 분석 run 생성 완료: meetingId={}, runId={}", meeting.getId(), runId);
+        return runId;
+    }
+
+    // FastAPI run 상태를 폴링하여 최종 완료 결과를 가져온다.
+    private TranscribeApplicationRunResponse pollTranscribeApplicationRun(String runId) {
+        FastApiException lastException = null;
+
+        for (int attempt = 1; attempt <= MAX_RUN_POLL_ATTEMPTS; attempt++) {
+            try {
+                FastApiResponse<TranscribeApplicationRunResponse> response = fastApiTranscribeClient.getTranscribeApplicationRun(runId);
+                TranscribeApplicationRunResponse runResponse = requireResult(response);
+
+                if (isFailed(runResponse)) {
+                    log.warn("FastAPI 전사 실행 실패: runId={}, error={}", runId, runResponse.error());
+                    throw new FastApiException(FastApiErrorCode.FAST_API_REQUEST_FAILED);
+                }
+
+                if (isCompleted(runResponse)) {
+                    return runResponse;
+                }
+            } catch (FastApiException e) {
+                if (!isTransientRunNotFound(e)) {
+                    throw e;
+                }
+                lastException = e;
+            }
+
+            sleep(RUN_POLL_WAIT_INTERVAL);
+        }
+
+        if (lastException != null) {
+            throw lastException;
+        }
+        throw new FastApiException(FastApiErrorCode.FAST_API_REQUEST_FAILED);
+    }
+
+    // run이 완료 상태인지 확인한다.
+    private boolean isCompleted(TranscribeApplicationRunResponse response) {
+        return "completed".equalsIgnoreCase(response.status())
+                && "applications_ready".equalsIgnoreCase(response.phase());
+    }
+
+    // run이 실패 상태인지 확인한다.
+    private boolean isFailed(TranscribeApplicationRunResponse response) {
+        return "failed".equalsIgnoreCase(response.status()) || "failed".equalsIgnoreCase(response.phase());
+    }
+
+    // FastAPI run not found가 일시적 상태인지 판별한다.
+    private boolean isTransientRunNotFound(FastApiException exception) {
+        Throwable cause = exception.getCause();
+        while (cause != null) {
+            if (cause instanceof HttpClientErrorException httpClientErrorException
+                    && httpClientErrorException.getStatusCode().value() == HttpStatus.NOT_FOUND.value()) {
+                return true;
+            }
+            if (cause instanceof RestClientResponseException restClientResponseException
+                    && restClientResponseException.getStatusCode().value() == HttpStatus.NOT_FOUND.value()) {
+                return true;
+            }
+            cause = cause.getCause();
+        }
+        return false;
+    }
+
+    // FastAPI 분석 결과를 회의 도메인 엔티티와 대화 목록으로 저장한다.
+    private void persistMeetingAnalysis(Meeting meeting, TranscribeApplicationRunResponse response) {
+        TranscribeApplicationRunResponse.TranscribeApplicationRunResult runResult = response.result();
+        if (runResult == null) {
+            throw new FastApiException(FastApiErrorCode.FAST_API_RESPONSE_EMPTY);
+        }
+
+        List<TranscribeApplicationRunResponse.TranscriptSegmentResponse> transcriptSegments =
+                Optional.ofNullable(runResult.transcriptSegments()).orElseGet(List::of);
+        TranscribeApplicationRunResponse.AnalysisResultResponse analysisResult = runResult.analysisResult();
+        TranscribeApplicationRunResponse.OverallAnalysisResponse overallAnalysis =
+                analysisResult != null ? analysisResult.overallAnalysis() : null;
+        MeetingAnalysis.MeetingAnalysisPayload payload = buildMeetingAnalysisPayload(overallAnalysis);
+
+        transactionTemplate.executeWithoutResult(status -> {
+            Meeting managedMeeting = meetingUseCase.findMeetingWithMembersById(meeting.getId());
+            meetingAnalysisRepository.deleteByMeetingId(managedMeeting.getId());
+            dialogueRepository.deleteByMeetingId(managedMeeting.getId());
+
+            MeetingAnalysis meetingAnalysis = MeetingAnalysis.create(managedMeeting, payload);
+            meetingAnalysisRepository.save(meetingAnalysis);
+            managedMeeting.attachMeetingAnalysis(meetingAnalysis);
+
+            List<Dialogue> dialogues = buildDialogues(managedMeeting, transcriptSegments);
+            if (!dialogues.isEmpty()) {
+                dialogueRepository.saveAll(dialogues);
+                dialogues.forEach(managedMeeting::addDialogue);
+            }
+        });
+
+        log.info("회의 오디오 분석 저장 완료: meetingId={}, transcriptSegmentCount={}", meeting.getId(), transcriptSegments.size());
+        // TODO: FastAPI의 applications 결과는 아직 저장하지 않는다.
+        // TODO: applications 저장 후 applicationId를 발급해 /api/meeting-analysis/embeddings로 전달한다.
+    }
+
+
+    // OverallAnalysis를 MeetingAnalysis 저장용 payload로 변환한다.
+    private MeetingAnalysis.MeetingAnalysisPayload buildMeetingAnalysisPayload(
+            TranscribeApplicationRunResponse.OverallAnalysisResponse overallAnalysis
+    ) {
+        if (overallAnalysis == null) {
+            return new MeetingAnalysis.MeetingAnalysisPayload(
+                    null,
+                    null,
+                    null,
+                    null,
+                    null,
+                    null,
+                    null,
+                    null
+            );
+        }
+
+        String analysisContent = serializeOverallAnalysis(overallAnalysis);
+        String meetingTitle = overallAnalysis.meetingInfo() != null ? overallAnalysis.meetingInfo().title() : null;
+        String meetingPurpose = overallAnalysis.meetingInfo() != null ? overallAnalysis.meetingInfo().purpose() : null;
+        String meetingDuration = overallAnalysis.meetingInfo() != null ? overallAnalysis.meetingInfo().duration() : null;
+        List<String> topics = overallAnalysis.topics();
+        List<String> coreContext = overallAnalysis.coreContext();
+        List<String> applicationTitles = overallAnalysis.applicationTitles();
+        List<String> applicationReasons = overallAnalysis.applicationReasons();
+
+        return new MeetingAnalysis.MeetingAnalysisPayload(
+                meetingTitle,
+                meetingPurpose,
+                meetingDuration,
+                analysisContent,
+                topics,
+                coreContext,
+                applicationTitles,
+                applicationReasons
+        );
+    }
+
+    // OverallAnalysis를 원본 JSON 문자열로 직렬화한다.
+    private String serializeOverallAnalysis(TranscribeApplicationRunResponse.OverallAnalysisResponse overallAnalysis) {
+        if (overallAnalysis == null) {
+            return null;
+        }
+
+        try {
+            return objectMapper.writeValueAsString(overallAnalysis);
+        } catch (JsonProcessingException e) {
+            log.warn("회의 분석 결과 직렬화 실패: {}", e.getMessage());
+            return null;
+        }
+    }
+
+    // 전사 세그먼트를 회의 참여자와 매칭해 Dialogue 목록으로 변환한다.
+    private List<Dialogue> buildDialogues(Meeting meeting,
+                                          List<TranscribeApplicationRunResponse.TranscriptSegmentResponse> transcriptSegments) {
+        if (transcriptSegments == null || transcriptSegments.isEmpty()) {
+            return List.of();
+        }
+
+        List<Member> members = meeting.getMeetingMembers().stream()
+                .map(MeetingMember::getMember)
+                .sorted(Comparator.comparing(Member::getId))
+                .toList();
+
+        if (members.isEmpty()) {
+            return List.of();
+        }
+
+        List<Dialogue> dialogues = new ArrayList<>();
+        for (int index = 0; index < transcriptSegments.size(); index++) {
+            TranscribeApplicationRunResponse.TranscriptSegmentResponse segment = transcriptSegments.get(index);
+            if (segment == null || segment.text() == null || segment.text().isBlank()) {
+                continue;
+            }
+
+            Member member = resolveMemberForSegment(members, segment.speaker(), index);
+            LocalDateTime speechDateTime = resolveSpeechDateTime(meeting.getStartDateTime(), segment.startTime(), index);
+            dialogues.add(Dialogue.create(meeting, member, segment.text().trim(), speechDateTime));
+        }
+
+        return dialogues;
+    }
+
+    // 세그먼트의 화자 정보를 기반으로 회의 참여자를 선택한다.
+    private Member resolveMemberForSegment(List<Member> members, String speaker, int index) {
+        if (speaker != null && !speaker.isBlank()) {
+            String normalizedSpeaker = speaker.trim().toLowerCase(Locale.ROOT);
+            for (Member member : members) {
+                if (member.getName() != null && member.getName().trim().toLowerCase(Locale.ROOT).equals(normalizedSpeaker)) {
+                    return member;
+                }
+            }
+
+            Integer speakerIndex = extractSpeakerIndex(speaker);
+            if (speakerIndex != null && speakerIndex >= 0 && speakerIndex < members.size()) {
+                return members.get(speakerIndex);
+            }
+        }
+
+        return members.get(Math.min(index, members.size() - 1));
+    }
+
+    // 화자 문자열에서 숫자 인덱스를 추출한다.
+    private Integer extractSpeakerIndex(String speaker) {
+        Matcher matcher = SPEAKER_INDEX_PATTERN.matcher(speaker);
+        if (matcher.find()) {
+            try {
+                return Integer.parseInt(matcher.group(1));
+            } catch (NumberFormatException ignored) {
+                return null;
+            }
+        }
+        return null;
+    }
+
+    // 전사 시작 시각 offset을 회의 시작 시각 기준 LocalDateTime으로 변환한다.
+    private LocalDateTime resolveSpeechDateTime(LocalDateTime meetingStartDateTime, String offset, int fallbackIndex) {
+        if (meetingStartDateTime == null) {
+            return LocalDateTime.now();
+        }
+
+        Duration duration = parseDuration(offset);
+        if (duration != null) {
+            return meetingStartDateTime.plus(duration);
+        }
+
+        return meetingStartDateTime.plusSeconds(fallbackIndex);
+    }
+
+    // 시간 문자열을 Duration으로 변환한다.
+    private Duration parseDuration(String offset) {
+        if (offset == null || offset.isBlank()) {
+            return null;
+        }
+
+        String[] parts = offset.trim().split(":");
+        if (parts.length != 3) {
+            return null;
+        }
+
+        try {
+            long hours = Long.parseLong(parts[0]);
+            long minutes = Long.parseLong(parts[1]);
+            double seconds = Double.parseDouble(parts[2]);
+            return Duration.ofHours(hours)
+                    .plusMinutes(minutes)
+                    .plusMillis(Math.round(seconds * 1000));
+        } catch (NumberFormatException e) {
+            return null;
+        }
+    }
+
+    // FastAPI 응답의 result가 비어 있으면 예외를 던진다.
+    private <T> T requireResult(FastApiResponse<T> response) {
+        if (response == null || response.result() == null) {
+            throw new FastApiException(FastApiErrorCode.FAST_API_RESPONSE_EMPTY);
+        }
+        return response.result();
+    }
+
+    // FastAPI에 전달할 오디오 URL Resource를 만든다.
+    private UrlResource buildAudioResource(String audioUrl) {
+        try {
+            return new UrlResource(audioUrl);
+        } catch (Exception e) {
+            throw new FastApiException(FastApiErrorCode.FAST_API_REQUEST_FAILED, e);
+        }
+    }
+
+    // 폴링/재시도 사이에 잠시 대기한다.
+    private void sleep(Duration duration) {
+        try {
+            TimeUnit.MILLISECONDS.sleep(duration.toMillis());
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new FastApiException(FastApiErrorCode.FAST_API_REQUEST_FAILED, e);
+        }
+    }
+}
diff --git a/src/main/java/com/whylog/server/domain/meeting/service/MeetingAudioDurationService.java b/src/main/java/com/whylog/server/domain/meeting/service/MeetingAudioDurationService.java
new file mode 100644
index 0000000..a7dfda2
--- /dev/null
+++ b/src/main/java/com/whylog/server/domain/meeting/service/MeetingAudioDurationService.java
@@ -0,0 +1,81 @@
+package com.whylog.server.domain.meeting.service;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.TimeUnit;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class MeetingAudioDurationService {
+
+    @Value("${audio.ffprobe-command}")
+    private String ffprobeCommand;
+
+    public Integer resolveAudioDurationSeconds(String audioUrl) {
+        if (audioUrl == null || audioUrl.isBlank()) {
+            return null;
+        }
+
+        return probeDurationSeconds(audioUrl);
+    }
+
+    private Integer probeDurationSeconds(String audioUrl) {
+        Process process;
+        try {
+            process = new ProcessBuilder(
+                    ffprobeCommand,
+                    "-v", "error",
+                    "-show_entries", "format=duration",
+                    "-of", "default=noprint_wrappers=1:nokey=1",
+                    audioUrl
+            ).redirectErrorStream(true).start();
+        } catch (IOException e) {
+            log.warn("ffprobe 실행 실패: {}", e.getMessage());
+            return null;
+        }
+
+        String output;
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
+            output = reader.readLine();
+        } catch (IOException e) {
+            log.warn("ffprobe 출력 읽기 실패: {}", e.getMessage());
+            process.destroyForcibly();
+            return null;
+        }
+
+        try {
+            if (!process.waitFor(10, TimeUnit.SECONDS)) {
+                log.warn("ffprobe 시간 초과");
+                process.destroyForcibly();
+                return null;
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            log.warn("ffprobe 대기 중 인터럽트 발생");
+            process.destroyForcibly();
+            return null;
+        }
+
+        if (process.exitValue() != 0 || output == null || output.isBlank()) {
+            return null;
+        }
+
+        try {
+            double seconds = Double.parseDouble(output.trim());
+            if (seconds <= 0) {
+                return null;
+            }
+            return (int) Math.round(seconds);
+        } catch (NumberFormatException e) {
+            log.warn("오디오 길이 파싱 실패: {}", e.getMessage());
+            return null;
+        }
+    }
+}
diff --git a/src/main/java/com/whylog/server/domain/meeting/service/MeetingAudioFileService.java b/src/main/java/com/whylog/server/domain/meeting/service/MeetingAudioFileService.java
new file mode 100644
index 0000000..1ef3fb0
--- /dev/null
+++ b/src/main/java/com/whylog/server/domain/meeting/service/MeetingAudioFileService.java
@@ -0,0 +1,56 @@
+package com.whylog.server.domain.meeting.service;
+
+import java.util.Locale;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MeetingAudioFileService {
+
+    public static final String AUDIO_FILE_SUFFIX = "-audio";
+    public static final String RECORDING_PREFIX = "recordings/meeting-";
+    public static final String MP4_EXTENSION = ".mp4";
+    public static final String OGG_EXTENSION = ".ogg";
+
+    public String buildRecordingKey(Long meetingId) {
+        return RECORDING_PREFIX + meetingId + AUDIO_FILE_SUFFIX + MP4_EXTENSION;
+    }
+
+    public String extractFileName(String audioKey) {
+        if (audioKey == null || audioKey.isBlank()) {
+            return null;
+        }
+
+        int lastSlashIndex = audioKey.lastIndexOf('/');
+        return lastSlashIndex >= 0 ? audioKey.substring(lastSlashIndex + 1) : audioKey;
+    }
+
+    public String alternateKey(String audioKey) {
+        if (audioKey == null || audioKey.isBlank()) {
+            return null;
+        }
+
+        String lowerCase = audioKey.toLowerCase(Locale.ROOT);
+        if (lowerCase.endsWith(MP4_EXTENSION)) {
+            return audioKey.substring(0, audioKey.length() - MP4_EXTENSION.length()) + OGG_EXTENSION;
+        }
+        if (lowerCase.endsWith(OGG_EXTENSION)) {
+            return audioKey.substring(0, audioKey.length() - OGG_EXTENSION.length()) + MP4_EXTENSION;
+        }
+        return audioKey;
+    }
+
+    public String resolveResponseContentType(String audioKey) {
+        if (audioKey == null || audioKey.isBlank()) {
+            return null;
+        }
+
+        String lowerCase = audioKey.toLowerCase(Locale.ROOT);
+        if (lowerCase.endsWith(OGG_EXTENSION)) {
+            return "audio/ogg";
+        }
+        if (lowerCase.endsWith(MP4_EXTENSION)) {
+            return "audio/mp4";
+        }
+        return null;
+    }
+}
diff --git a/src/main/java/com/whylog/server/domain/meeting/service/MeetingAudioKeyResolver.java b/src/main/java/com/whylog/server/domain/meeting/service/MeetingAudioKeyResolver.java
new file mode 100644
index 0000000..c454eb5
--- /dev/null
+++ b/src/main/java/com/whylog/server/domain/meeting/service/MeetingAudioKeyResolver.java
@@ -0,0 +1,33 @@
+package com.whylog.server.domain.meeting.service;
+
+import com.whylog.server.domain.meeting.entity.Meeting;
+import com.whylog.server.global.external.s3.S3Client;
+import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class MeetingAudioKeyResolver {
+
+    private final MeetingAudioFileService meetingAudioFileService;
+    private final S3Client s3Client;
+
+    public Optional<String> resolvePlayableAudioKey(Meeting meeting) {
+        String audioKey = meeting.getAudioKey();
+        if (isPlayable(audioKey)) {
+            return Optional.of(audioKey);
+        }
+
+        String alternateAudioKey = meetingAudioFileService.alternateKey(audioKey);
+        if (isPlayable(alternateAudioKey)) {
+            return Optional.of(alternateAudioKey);
+        }
+
+        return Optional.empty();
+    }
+
+    private boolean isPlayable(String audioKey) {
+        return audioKey != null && !audioKey.isBlank() && s3Client.exists(audioKey);
+    }
+}
diff --git a/src/main/java/com/whylog/server/domain/meeting/service/MeetingAudioReplayService.java b/src/main/java/com/whylog/server/domain/meeting/service/MeetingAudioReplayService.java
new file mode 100644
index 0000000..ff718b0
--- /dev/null
+++ b/src/main/java/com/whylog/server/domain/meeting/service/MeetingAudioReplayService.java
@@ -0,0 +1,55 @@
+package com.whylog.server.domain.meeting.service;
+
+import com.whylog.server.domain.meeting.dto.MeetingResponse;
+import com.whylog.server.domain.meeting.entity.Meeting;
+import com.whylog.server.domain.meeting.exception.MeetingAudioNotReadyException;
+import com.whylog.server.global.external.s3.S3Client;
+import java.time.Duration;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class MeetingAudioReplayService {
+
+    private static final Duration AUDIO_URL_EXPIRE_DURATION = Duration.ofMinutes(10);
+
+    private final MeetingAudioKeyResolver meetingAudioKeyResolver;
+    private final MeetingAudioDurationService meetingAudioDurationService;
+    private final MeetingAudioFileService meetingAudioFileService;
+    private final S3Client s3Client;
+
+    public MeetingResponse.AudioDTO buildAudioResponse(Meeting meeting) {
+        String audioKey = meetingAudioKeyResolver.resolvePlayableAudioKey(meeting)
+                .orElseThrow(MeetingAudioNotReadyException::new);
+        String audioUrl = buildPlayableAudioUrl(audioKey);
+
+        return MeetingResponse.AudioDTO.builder()
+                .meetingId(meeting.getId())
+                .audioKey(audioKey)
+                .audioUrl(audioUrl)
+                .audioDuration(meetingAudioDurationService.resolveAudioDurationSeconds(audioUrl))
+                .build();
+    }
+
+    public String resolvePlayableAudioUrl(Meeting meeting) {
+        String audioKey = meetingAudioKeyResolver.resolvePlayableAudioKey(meeting)
+                .orElseThrow(MeetingAudioNotReadyException::new);
+        return buildPlayableAudioUrl(audioKey);
+    }
+
+    public Integer resolveAudioDurationIfAvailable(Meeting meeting) {
+        return meetingAudioKeyResolver.resolvePlayableAudioKey(meeting)
+                .map(this::buildPlayableAudioUrl)
+                .map(meetingAudioDurationService::resolveAudioDurationSeconds)
+                .orElse(null);
+    }
+
+    private String buildPlayableAudioUrl(String audioKey) {
+        return s3Client.getPresignedFileUrl(
+                audioKey,
+                AUDIO_URL_EXPIRE_DURATION,
+                meetingAudioFileService.resolveResponseContentType(audioKey)
+        );
+    }
+}
diff --git a/src/main/java/com/whylog/server/domain/meeting/service/MeetingCleanupService.java b/src/main/java/com/whylog/server/domain/meeting/service/MeetingCleanupService.java
index e3a2117..ac190c5 100644
--- a/src/main/java/com/whylog/server/domain/meeting/service/MeetingCleanupService.java
+++ b/src/main/java/com/whylog/server/domain/meeting/service/MeetingCleanupService.java
@@ -25,7 +25,7 @@ public class MeetingCleanupService {
     @Transactional
     public List<Long> deleteByTeamId(Long teamId) {
         List<Long> meetingIds = meetingRepository.findIdsByTeamId(teamId);
-        deleteChildrenByTeamId(teamId);
+        deleteChildrenByTeamId(teamId, meetingIds);
         meetingRepository.deleteByTeamId(teamId);
         return meetingIds;
     }
@@ -36,7 +36,7 @@ public void deleteByMeetingId(Long meetingId) {
         meetingRepository.deleteById(meetingId);
     }
 
-    private void deleteChildrenByTeamId(Long teamId) {
+    private void deleteChildrenByTeamId(Long teamId, List<Long> meetingIds) {
         applicationRepository.deleteByTeamId(teamId);
         decisionRepository.deleteByTeamId(teamId);
         meetingAnalysisRepository.deleteByTeamId(teamId);
diff --git a/src/main/java/com/whylog/server/domain/meeting/service/MeetingCommandService.java b/src/main/java/com/whylog/server/domain/meeting/service/MeetingCommandService.java
index fd6fb00..a2fd781 100644
--- a/src/main/java/com/whylog/server/domain/meeting/service/MeetingCommandService.java
+++ b/src/main/java/com/whylog/server/domain/meeting/service/MeetingCommandService.java
@@ -12,28 +12,38 @@
 import com.whylog.server.domain.meeting.repository.MeetingMemberRepository;
 import com.whylog.server.domain.meeting.repository.MeetingRepository;
 import com.whylog.server.domain.meeting.socket.MeetingSocketRoomService;
+import com.whylog.server.domain.meeting.service.MeetingAnalysisService;
 import com.whylog.server.domain.meeting.service.MeetingCleanupService;
+import com.whylog.server.domain.meeting.service.LiveKitTokenService;
 import com.whylog.server.domain.team.entity.Team;
 import com.whylog.server.domain.team.service.TeamUseCase;
 import com.whylog.server.domain.user.entity.Member;
 import com.whylog.server.domain.user.service.MemberUseCase;
+import com.whylog.server.global.external.livekit.LiveKitEgressClient;
 import com.whylog.server.global.apiPayload.exception.handler.ErrorHandler;
 import com.whylog.server.global.apiPayload.exception.ParameterRequiredException;
+import java.util.concurrent.CompletableFuture;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.support.TransactionSynchronization;
 import org.springframework.transaction.support.TransactionSynchronizationManager;
+import lombok.extern.slf4j.Slf4j;
 
 import java.time.LocalDateTime;
 
 @Service
+@Slf4j
 @RequiredArgsConstructor
 public class MeetingCommandService {
 
     private final MeetingMemberRepository meetingMemberRepository;
     private final MeetingRepository meetingRepository;
     private final MeetingCleanupService meetingCleanupService;
+    private final MeetingAudioFileService meetingAudioFileService;
+    private final MeetingAnalysisService meetingAnalysisService;
+    private final LiveKitTokenService liveKitTokenService;
+    private final LiveKitEgressClient liveKitEgressClient;
 
     private final MemberUseCase memberUseCase;
     private final TeamUseCase teamUseCase;
@@ -63,6 +73,9 @@ public MeetingResponse.MeetingCreateResponseDTO makeMeetingRoom(Long memberId, L
         // Meeting, MeetingMember 같이 저장
         Meeting meeting = Meeting.create(requestDTO, team);
         Meeting savedMeeting = meetingRepository.save(meeting);
+        String audioKey = meetingAudioFileService.buildRecordingKey(savedMeeting.getId());
+        savedMeeting.setAudioKey(audioKey);
+        meetingRepository.save(savedMeeting);
         MeetingMember meetingMember = MeetingMember.create(savedMeeting, member, MeetingRole.OWNER);
         meetingMemberRepository.save(meetingMember);
 
@@ -102,9 +115,14 @@ public MeetingResponse.MeetingEndResponseDTO endMeeting(Long memberId, Long meet
 
         // 웹소켓 메시지 전송
         meetingSocketRoomService.broadcastMeetingEnded(meetingId, endDateTime); // 회의 참여한 사람들에게 알림
+        stopRecording(meeting);
         meetingSocketRoomService.closeRoom(meetingId); // 메모리 내의 실시간 회의 정보 제거
 
-        // TODO: 회의 종료 후 분석 비동기 작업 시작
+        scheduleAfterCommit(() -> CompletableFuture.runAsync(() -> meetingAnalysisService.analyzeMeetingAudio(meeting.getId()))
+                .exceptionally(ex -> {
+                    log.error("회의 오디오 분석 실패: meetingId={}", meeting.getId(), ex);
+                    return null;
+                }));
 
         return MeetingResponse.MeetingEndResponseDTO.builder()
                 .meetingId(meeting.getId())
@@ -121,6 +139,9 @@ public MeetingResponse.MeetingDeleteResponseDTO deleteMeeting(Long memberId, Lon
         meetingMemberRepository.findOwnerMeetingMember(memberId, meetingId, MeetingRole.OWNER)
                 .orElseThrow(() -> new ErrorHandler(MeetingErrorCode.MEETING_NOT_OWNER));
 
+        Meeting meeting = meetingRepository.findById(meetingId)
+                .orElseThrow(MeetingNotFoundException::new);
+        stopRecording(meeting);
         meetingCleanupService.deleteByMeetingId(meetingId);
         scheduleAfterCommit(() -> meetingSocketRoomService.closeRoom(meetingId));
 
@@ -144,4 +165,14 @@ public void afterCommit() {
         task.run();
     }
 
+    private void stopRecording(Meeting meeting) {
+        if (meeting == null || meeting.getAudioEgressId() == null || meeting.getAudioEgressId().isBlank()) {
+            return;
+        }
+
+        String roomName = "meeting-" + meeting.getId();
+        String egressToken = liveKitTokenService.createRoomRecordToken("recording-" + meeting.getId(), roomName);
+        liveKitEgressClient.stopEgress(egressToken, meeting.getAudioEgressId());
+    }
+
 }
diff --git a/src/main/java/com/whylog/server/domain/meeting/service/MeetingQueryService.java b/src/main/java/com/whylog/server/domain/meeting/service/MeetingQueryService.java
index 088db8a..132c2f7 100644
--- a/src/main/java/com/whylog/server/domain/meeting/service/MeetingQueryService.java
+++ b/src/main/java/com/whylog/server/domain/meeting/service/MeetingQueryService.java
@@ -2,9 +2,8 @@
 
 import com.whylog.server.domain.meeting.dto.MeetingResponse;
 import com.whylog.server.domain.meeting.entity.Meeting;
+import com.whylog.server.domain.meeting.entity.MeetingAnalysis;
 import com.whylog.server.domain.meeting.enums.MeetingStatus;
-import com.whylog.server.domain.meeting.exception.MeetingNotFoundException;
-import com.whylog.server.domain.meeting.repository.MeetingRepository;
 import com.whylog.server.domain.user.entity.Member;
 import com.whylog.server.global.apiPayload.exception.ParameterRequiredException;
 import lombok.RequiredArgsConstructor;
@@ -17,8 +16,8 @@
 @RequiredArgsConstructor
 public class MeetingQueryService {
 
-    private final MeetingRepository meetingRepository;
     private final MeetingUseCase meetingUseCase;
+    private final MeetingAudioReplayService meetingAudioReplayService;
 
     // 미팅 목록 조회
     @Transactional(readOnly = true)
@@ -27,7 +26,7 @@ public List<MeetingResponse.MeetingListDTO> getMeetings(Long teamId, MeetingStat
         // 기본값: 진행완료
         MeetingStatus targetStatus = status != null ? status : MeetingStatus.COMPLETED;
 
-        List<Meeting> meetings = meetingRepository.findByTeamId(teamId);
+        List<Meeting> meetings = meetingUseCase.findMeetingByTeamId(teamId);
 
         return meetings.stream()
                 .filter( m -> checkMeetingStatus(m, targetStatus)) // 상태 일치 체크
@@ -49,8 +48,7 @@ public MeetingResponse.MeetingDetailDTO getMeetingDefaultInfo(Long meetingId){
             throw new ParameterRequiredException();
         }
 
-        Meeting meeting = meetingRepository.findWithMembers(meetingId)
-                .orElseThrow(MeetingNotFoundException::new);
+        Meeting meeting = meetingUseCase.findMeetingById(meetingId);
 
         return MeetingResponse.MeetingDetailDTO.builder()
                 .meetingId(meeting.getId())
@@ -60,6 +58,7 @@ public MeetingResponse.MeetingDetailDTO getMeetingDefaultInfo(Long meetingId){
                 .duration(meeting.getDuration())
                 .memberCount( meetingUseCase.getMeetingMemberCount(meeting) )
                 .members( memberToParticipantsInfo(meetingUseCase.getParticipantsInfo(meeting)) )
+                .audioDuration( meetingAudioReplayService.resolveAudioDurationIfAvailable(meeting) )
                 .build();
     }
 
@@ -77,4 +76,25 @@ private boolean checkMeetingStatus(Meeting meeting, MeetingStatus status){
         return meeting.getStatus() == status;
     }
 
+    @Transactional(readOnly = true)
+    public MeetingResponse.AudioDTO getMeetingAudio(Long meetingId) {
+        Meeting meeting = meetingUseCase.findMeetingById(meetingId);
+        return meetingAudioReplayService.buildAudioResponse(meeting);
+    }
+
+    @Transactional(readOnly = true)
+    public MeetingResponse.AnalysisResultDTO getAnalysis(Long meetingId) {
+
+        meetingUseCase.findMeetingById(meetingId); // 없으면 그거에 따른 예외 발생
+
+        MeetingAnalysis meetingAnalysis = meetingUseCase.findAnalysisByMeetingId(meetingId)
+                .orElse(null);
+
+        if(meetingAnalysis == null) // null이면 isAnalyzed = false인 응답 반환
+            return MeetingResponse.AnalysisResultDTO.createFalse(meetingId);
+
+        Integer audioDuration = meetingAudioReplayService.resolveAudioDurationIfAvailable(meetingAnalysis.getMeeting());
+        return MeetingResponse.AnalysisResultDTO.create(meetingAnalysis, audioDuration);
+    }
+
 }
diff --git a/src/main/java/com/whylog/server/domain/meeting/service/MeetingRtcService.java b/src/main/java/com/whylog/server/domain/meeting/service/MeetingRtcService.java
index fa24e8c..8771df8 100644
--- a/src/main/java/com/whylog/server/domain/meeting/service/MeetingRtcService.java
+++ b/src/main/java/com/whylog/server/domain/meeting/service/MeetingRtcService.java
@@ -9,45 +9,39 @@
 import com.whylog.server.domain.meeting.repository.MeetingRepository;
 import com.whylog.server.domain.user.entity.Member;
 import com.whylog.server.domain.user.service.MemberUseCase;
-import io.jsonwebtoken.Jwts;
-import io.jsonwebtoken.security.Keys;
+import com.whylog.server.global.external.livekit.LiveKitEgressClient;
 import jakarta.validation.constraints.NotBlank;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import javax.crypto.SecretKey;
-import java.nio.charset.StandardCharsets;
-import java.util.Date;
-import java.util.Map;
-
 @Service
 public class MeetingRtcService {
 
     private final MeetingRepository meetingRepository;
     private final MeetingMemberRepository meetingMemberRepository;
     private final MemberUseCase memberUseCase;
+    private final MeetingAudioFileService meetingAudioFileService;
+    private final LiveKitTokenService liveKitTokenService;
+    private final LiveKitEgressClient liveKitEgressClient;
     private final String liveKitUrl;
-    private final String liveKitApiKey;
-    private final String liveKitApiSecret;
-    private final long liveKitTokenExpireTime;
 
     public MeetingRtcService(
             MeetingRepository meetingRepository,
             MeetingMemberRepository meetingMemberRepository,
             MemberUseCase memberUseCase,
-            @Value("${livekit.url}") @NotBlank String liveKitUrl,
-            @Value("${livekit.api-key}") @NotBlank String liveKitApiKey,
-            @Value("${livekit.api-secret}") @NotBlank String liveKitApiSecret,
-            @Value("${livekit.token-expire-time}") long liveKitTokenExpireTime
+            MeetingAudioFileService meetingAudioFileService,
+            LiveKitTokenService liveKitTokenService,
+            LiveKitEgressClient liveKitEgressClient,
+            @Value("${livekit.url}") @NotBlank String liveKitUrl
     ) {
         this.meetingRepository = meetingRepository;
         this.meetingMemberRepository = meetingMemberRepository;
         this.memberUseCase = memberUseCase;
+        this.meetingAudioFileService = meetingAudioFileService;
+        this.liveKitTokenService = liveKitTokenService;
+        this.liveKitEgressClient = liveKitEgressClient;
         this.liveKitUrl = liveKitUrl;
-        this.liveKitApiKey = liveKitApiKey;
-        this.liveKitApiSecret = liveKitApiSecret;
-        this.liveKitTokenExpireTime = liveKitTokenExpireTime;
     }
 
     @Transactional
@@ -58,8 +52,9 @@ public MeetingResponse.MeetingRtcTokenDTO issueRtcToken(Long memberId, Long meet
         Member member = memberUseCase.findMemberById(memberId);
         ensureMeetingParticipant(meeting, member);
         String roomName = buildRoomName(meeting);
+        startRecordingIfAbsent(meeting, roomName);
         String identity = String.valueOf(member.getId());
-        String token = createJoinToken(identity, member.getName(), roomName);
+        String token = liveKitTokenService.createJoinToken(identity, member.getName(), roomName);
 
         return MeetingResponse.MeetingRtcTokenDTO.builder()
                 .meetingId(meetingId)
@@ -80,31 +75,23 @@ private String buildRoomName(Meeting meeting) {
         return "meeting-" + meeting.getId();
     }
 
-    private String createJoinToken(String identity, String name, String roomName) {
-        Date now = new Date();
-        Date expiration = new Date(now.getTime() + liveKitTokenExpireTime);
+    private void startRecordingIfAbsent(Meeting meeting, String roomName) {
+        if (meeting.getAudioEgressId() != null && !meeting.getAudioEgressId().isBlank()) {
+            return;
+        }
 
-        Map<String, Object> videoGrant = Map.of(
-                "roomJoin", true,
-                "room", roomName,
-                "canPublish", true,
-                "canSubscribe", true,
-                "canPublishData", true
-        );
+        String audioKey = meeting.getAudioKey();
+        if (audioKey == null || audioKey.isBlank()) {
+            audioKey = meetingAudioFileService.buildRecordingKey(meeting.getId());
+            meeting.setAudioKey(audioKey);
+        }
 
-        return Jwts.builder()
-                .setIssuer(liveKitApiKey)
-                .setSubject(identity)
-                .setIssuedAt(now)
-                .setNotBefore(now)
-                .setExpiration(expiration)
-                .claim("name", name)
-                .claim("video", videoGrant)
-                .signWith(getSigningKey())
-                .compact();
-    }
+        String roomAdminToken = liveKitTokenService.createRoomCreateToken("room-admin");
+        liveKitEgressClient.createRoom(roomAdminToken, roomName);
 
-    private SecretKey getSigningKey() {
-        return Keys.hmacShaKeyFor(liveKitApiSecret.getBytes(StandardCharsets.UTF_8));
+        String egressToken = liveKitTokenService.createRoomRecordToken("recording-" + meeting.getId(), roomName);
+        String egressId = liveKitEgressClient.startRoomAudioEgress(egressToken, roomName, audioKey);
+        meeting.setAudioEgressId(egressId);
+        meetingRepository.save(meeting);
     }
 }
diff --git a/src/main/java/com/whylog/server/domain/meeting/service/MeetingUseCase.java b/src/main/java/com/whylog/server/domain/meeting/service/MeetingUseCase.java
index 4b2c897..63c7cde 100644
--- a/src/main/java/com/whylog/server/domain/meeting/service/MeetingUseCase.java
+++ b/src/main/java/com/whylog/server/domain/meeting/service/MeetingUseCase.java
@@ -1,19 +1,38 @@
 package com.whylog.server.domain.meeting.service;
 
 import com.whylog.server.domain.meeting.entity.Meeting;
+import com.whylog.server.domain.meeting.entity.MeetingAnalysis;
 import com.whylog.server.domain.meeting.entity.MeetingMember;
+import com.whylog.server.domain.meeting.exception.MeetingNotFoundException;
+import com.whylog.server.domain.meeting.repository.MeetingAnalysisRepository;
 import com.whylog.server.domain.meeting.repository.MeetingRepository;
 import com.whylog.server.domain.user.entity.Member;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
+import java.util.Optional;
 
 @Service
 @RequiredArgsConstructor
 public class MeetingUseCase {
 
     private final MeetingRepository meetingRepository;
+    private final MeetingAnalysisRepository meetingAnalysisRepository;
+
+    public Meeting findMeetingById(Long id){
+        return meetingRepository.findById(id)
+                .orElseThrow(MeetingNotFoundException::new);
+    }
+
+    public Meeting findMeetingWithMembersById(Long id){
+        return meetingRepository.findWithMembers(id)
+                .orElseThrow(MeetingNotFoundException::new);
+    }
+
+    public List<Meeting> findMeetingByTeamId(Long teamId){
+        return meetingRepository.findByTeamId(teamId);
+    }
 
     // 회의 참여자 수
     public int getMeetingMemberCount(Meeting meeting){
@@ -27,4 +46,8 @@ public List<Member> getParticipantsInfo(Meeting meeting){
                 .toList();
     }
 
+    public Optional<MeetingAnalysis> findAnalysisByMeetingId(Long meetingId) {
+        return meetingAnalysisRepository.findByMeetingId(meetingId);
+    }
+
 }
diff --git a/src/main/java/com/whylog/server/global/config/S3Config.java b/src/main/java/com/whylog/server/global/config/S3Config.java
index 07774cd..cc4b353 100644
--- a/src/main/java/com/whylog/server/global/config/S3Config.java
+++ b/src/main/java/com/whylog/server/global/config/S3Config.java
@@ -6,6 +6,7 @@
 import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
 import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
 import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.s3.presigner.S3Presigner;
 
 @Configuration
 public class S3Config {
@@ -23,4 +24,18 @@ public software.amazon.awssdk.services.s3.S3Client amazonS3Client(
                 ))
                 .build();
     }
+
+    @Bean
+    public S3Presigner s3Presigner(
+            @Value("${aws.s3.region}") String region,
+            @Value("${aws.s3.access-key}") String accessKey,
+            @Value("${aws.s3.secret-key}") String secretKey
+    ) {
+        return S3Presigner.builder()
+                .region(Region.of(region))
+                .credentialsProvider(StaticCredentialsProvider.create(
+                        AwsBasicCredentials.create(accessKey, secretKey)
+                ))
+                .build();
+    }
 }
diff --git a/src/main/java/com/whylog/server/global/external/fast/FastApiInfo.java b/src/main/java/com/whylog/server/global/external/fast/FastApiInfo.java
new file mode 100644
index 0000000..34bfb99
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/FastApiInfo.java
@@ -0,0 +1,29 @@
+package com.whylog.server.global.external.fast;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import org.springframework.http.HttpMethod;
+
+@Getter
+@AllArgsConstructor
+public enum FastApiInfo {
+
+    READ_ROOT(HttpMethod.GET, "/", FastApiRequestBodyType.NONE),
+    HEALTH_CHECK(HttpMethod.GET, "/health", FastApiRequestBodyType.NONE),
+
+    TRANSCRIBE_AUDIO(HttpMethod.POST, "/api/transcribe", FastApiRequestBodyType.MULTIPART),
+    TRANSCRIBE_APPLICATIONS(HttpMethod.POST, "/api/transcribe/applications", FastApiRequestBodyType.MULTIPART),
+    TRANSCRIBE_APPLICATION_RUNS(HttpMethod.POST, "/api/transcribe/applications/runs", FastApiRequestBodyType.MULTIPART),
+    TRANSCRIBE_APPLICATION_RUN_STATUS(HttpMethod.GET, "/api/transcribe/applications/runs/{run_id}", FastApiRequestBodyType.NONE),
+
+    MEETING_ANALYSIS_EXTRACT(HttpMethod.POST, "/api/meeting-analysis/extract", FastApiRequestBodyType.JSON),
+    MEETING_ANALYSIS_EMBEDDINGS(HttpMethod.POST, "/api/meeting-analysis/embeddings", FastApiRequestBodyType.JSON),
+
+    COMMIT_ANALYZE(HttpMethod.POST, "/api/commit/analyze", FastApiRequestBodyType.JSON),
+    COMMIT_MATCH(HttpMethod.POST, "/api/commit/match", FastApiRequestBodyType.JSON);
+
+    private final HttpMethod method;
+    private final String path;
+    private final FastApiRequestBodyType fastApiRequestBodyType;
+
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/FastApiRequestBodyType.java b/src/main/java/com/whylog/server/global/external/fast/FastApiRequestBodyType.java
new file mode 100644
index 0000000..8b8d68d
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/FastApiRequestBodyType.java
@@ -0,0 +1,7 @@
+package com.whylog.server.global.external.fast;
+
+public enum FastApiRequestBodyType {
+    NONE,
+    JSON,
+    MULTIPART
+}
\ No newline at end of file
diff --git a/src/main/java/com/whylog/server/global/external/fast/client/FastApiBinaryPart.java b/src/main/java/com/whylog/server/global/external/fast/client/FastApiBinaryPart.java
new file mode 100644
index 0000000..6e5ff8f
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/client/FastApiBinaryPart.java
@@ -0,0 +1,11 @@
+package com.whylog.server.global.external.fast.client;
+
+import org.springframework.core.io.Resource;
+
+public record FastApiBinaryPart(
+        String partName,
+        Resource resource,
+        String filename,
+        String contentType
+) {
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/client/FastApiClient.java b/src/main/java/com/whylog/server/global/external/fast/client/FastApiClient.java
new file mode 100644
index 0000000..ce8df47
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/client/FastApiClient.java
@@ -0,0 +1,133 @@
+package com.whylog.server.global.external.fast.client;
+
+import java.net.URI;
+import java.util.Map;
+
+import com.whylog.server.global.external.fast.exception.FastApiException;
+import com.whylog.server.global.external.fast.exception.FastApiErrorCode;
+import com.whylog.server.global.external.fast.FastApiInfo;
+import com.whylog.server.global.external.fast.FastApiRequestBodyType;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.client.MultipartBodyBuilder;
+import org.springframework.lang.Nullable;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.util.StringUtils;
+import org.springframework.web.client.RestClientException;
+import org.springframework.web.client.RestClient;
+import org.springframework.web.util.UriComponentsBuilder;
+
+@Slf4j
+public class FastApiClient {
+
+    private final RestClient restClient;
+
+    @Value("${fast.api.base-url}")
+    private String baseUrl;
+
+    protected FastApiClient() {
+        this.restClient = RestClient.create();
+    }
+
+    protected <T> T get(FastApiInfo fastApiInfo,
+                        @Nullable Map<String, ?> pathVariables,
+                        ParameterizedTypeReference<T> responseType) {
+        return execute(fastApiInfo, pathVariables, null, null, responseType);
+    }
+
+    protected <T> T postJson(FastApiInfo fastApiInfo,
+                             Object request,
+                             ParameterizedTypeReference<T> responseType) {
+        return execute(fastApiInfo, Map.of(), request, null, responseType);
+    }
+
+    protected <T> T postMultipart(FastApiInfo fastApiInfo,
+                                  @Nullable Map<String, ?> textParts,
+                                  @Nullable FastApiBinaryPart binaryPart,
+                                  ParameterizedTypeReference<T> responseType) {
+        MultiValueMap<String, HttpEntity<?>> multipartBody = buildMultipartBody(textParts, binaryPart);
+        return execute(fastApiInfo, Map.of(), null, multipartBody, responseType);
+    }
+
+    private <T> T execute(FastApiInfo fastApiInfo,
+                          @Nullable Map<String, ?> pathVariables,
+                          @Nullable Object jsonBody,
+                          @Nullable MultiValueMap<String, HttpEntity<?>> multipartBody,
+                          ParameterizedTypeReference<T> responseType) {
+        try {
+            URI uri = buildUri(fastApiInfo, pathVariables);
+            HttpMethod method = fastApiInfo.getMethod();
+
+            log.info("FastAPI request: {} {}", method, uri);
+
+            RestClient.RequestBodyUriSpec requestSpec = restClient.method(method);
+            RestClient.RequestBodySpec bodySpec = requestSpec.uri(uri);
+
+            if (fastApiInfo.getFastApiRequestBodyType() == FastApiRequestBodyType.MULTIPART) {
+                if (multipartBody == null) {
+                    throw new FastApiException(FastApiErrorCode.FAST_API_INVALID_REQUEST_BODY);
+                }
+                bodySpec.contentType(MediaType.MULTIPART_FORM_DATA);
+                return bodySpec.body(multipartBody)
+                        .retrieve()
+                        .body(responseType);
+            }
+
+            if (fastApiInfo.getFastApiRequestBodyType() == FastApiRequestBodyType.JSON) {
+                bodySpec.contentType(MediaType.APPLICATION_JSON);
+            }
+            if (jsonBody != null) {
+                return bodySpec.body(jsonBody)
+                        .retrieve()
+                        .body(responseType);
+            }
+
+            return bodySpec.retrieve().body(responseType);
+        } catch (RestClientException e) {
+            log.warn("FastAPI request failed: {}", fastApiInfo.name(), e);
+            throw new FastApiException(FastApiErrorCode.FAST_API_REQUEST_FAILED, e);
+        }
+    }
+
+    private URI buildUri(FastApiInfo fastApiInfo, @Nullable Map<String, ?> pathVariables) {
+        Map<String, ?> variables = pathVariables == null ? Map.of() : pathVariables;
+        return UriComponentsBuilder.fromHttpUrl(trimTrailingSlash(baseUrl))
+                .path(fastApiInfo.getPath())
+                .buildAndExpand(variables)
+                .toUri();
+    }
+
+    private MultiValueMap<String, HttpEntity<?>> buildMultipartBody(@Nullable Map<String, ?> textParts,
+                                                                    @Nullable FastApiBinaryPart binaryPart) {
+        MultipartBodyBuilder builder = new MultipartBodyBuilder();
+
+        if (textParts != null) {
+            textParts.forEach((key, value) -> {
+                if (value != null) {
+                    builder.part(key, value);
+                }
+            });
+        }
+
+        if (binaryPart != null) {
+            MultipartBodyBuilder.PartBuilder partBuilder = builder.part(binaryPart.partName(), binaryPart.resource());
+            if (StringUtils.hasText(binaryPart.filename())) {
+                partBuilder.filename(binaryPart.filename());
+            }
+            if (StringUtils.hasText(binaryPart.contentType())) {
+                partBuilder.contentType(MediaType.parseMediaType(binaryPart.contentType()));
+            }
+        }
+
+        return new LinkedMultiValueMap<>(builder.build());
+    }
+
+    private String trimTrailingSlash(String value) {
+        return value.endsWith("/") ? value.substring(0, value.length() - 1) : value;
+    }
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/client/FastApiCommitClient.java b/src/main/java/com/whylog/server/global/external/fast/client/FastApiCommitClient.java
new file mode 100644
index 0000000..75473a0
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/client/FastApiCommitClient.java
@@ -0,0 +1,32 @@
+package com.whylog.server.global.external.fast.client;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import java.util.Map;
+
+import com.whylog.server.global.external.fast.FastApiInfo;
+import com.whylog.server.global.external.fast.dto.FastApiResponse;
+import com.whylog.server.global.external.fast.dto.request.CommitAnalyzeRequest;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.stereotype.Component;
+
+@Component
+public class FastApiCommitClient extends FastApiClient {
+
+    public FastApiResponse<JsonNode> analyzeCommit(CommitAnalyzeRequest request) {
+        return postJson(
+                FastApiInfo.COMMIT_ANALYZE,
+                request,
+                new ParameterizedTypeReference<>() {
+                }
+        );
+    }
+
+    public FastApiResponse<JsonNode> matchApplicationCommits(Map<String, Object> request) {
+        return postJson(
+                FastApiInfo.COMMIT_MATCH,
+                request,
+                new ParameterizedTypeReference<>() {
+                }
+        );
+    }
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/client/FastApiMeetingAnalysisClient.java b/src/main/java/com/whylog/server/global/external/fast/client/FastApiMeetingAnalysisClient.java
new file mode 100644
index 0000000..10dd5e2
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/client/FastApiMeetingAnalysisClient.java
@@ -0,0 +1,32 @@
+package com.whylog.server.global.external.fast.client;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import java.util.Map;
+
+import com.whylog.server.global.external.fast.FastApiInfo;
+import com.whylog.server.global.external.fast.dto.FastApiResponse;
+import com.whylog.server.global.external.fast.dto.request.MeetingAnalysisRequest;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.stereotype.Component;
+
+@Component
+public class FastApiMeetingAnalysisClient extends FastApiClient {
+
+    public FastApiResponse<JsonNode> extractMeetingAnalysis(MeetingAnalysisRequest request) {
+        return postJson(
+                FastApiInfo.MEETING_ANALYSIS_EXTRACT,
+                request,
+                new ParameterizedTypeReference<>() {
+                }
+        );
+    }
+
+    public FastApiResponse<JsonNode> createApplicationEmbeddings(Map<String, Object> request) {
+        return postJson(
+                FastApiInfo.MEETING_ANALYSIS_EMBEDDINGS,
+                request,
+                new ParameterizedTypeReference<>() {
+                }
+        );
+    }
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/client/FastApiSystemClient.java b/src/main/java/com/whylog/server/global/external/fast/client/FastApiSystemClient.java
new file mode 100644
index 0000000..019de7d
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/client/FastApiSystemClient.java
@@ -0,0 +1,30 @@
+package com.whylog.server.global.external.fast.client;
+
+import java.util.Map;
+
+import com.whylog.server.global.external.fast.FastApiInfo;
+import com.whylog.server.global.external.fast.dto.FastApiResponse;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.stereotype.Component;
+
+@Component
+public class FastApiSystemClient extends FastApiClient {
+
+    public FastApiResponse<Map<String, String>> readRoot() {
+        return get(
+                FastApiInfo.READ_ROOT,
+                Map.of(),
+                new ParameterizedTypeReference<>() {
+                }
+        );
+    }
+
+    public FastApiResponse<Map<String, String>> healthCheck() {
+        return get(
+                FastApiInfo.HEALTH_CHECK,
+                Map.of(),
+                new ParameterizedTypeReference<>() {
+                }
+        );
+    }
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/client/FastApiTranscribeClient.java b/src/main/java/com/whylog/server/global/external/fast/client/FastApiTranscribeClient.java
new file mode 100644
index 0000000..931f0a2
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/client/FastApiTranscribeClient.java
@@ -0,0 +1,125 @@
+package com.whylog.server.global.external.fast.client;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.whylog.server.global.external.fast.FastApiInfo;
+import com.whylog.server.global.external.fast.dto.FastApiResponse;
+import com.whylog.server.global.external.fast.dto.request.TranscribeRequest;
+import com.whylog.server.global.external.fast.dto.response.TranscribeApplicationRunCreateResponse;
+import com.whylog.server.global.external.fast.dto.response.TranscribeApplicationRunResponse;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.core.io.Resource;
+import org.springframework.stereotype.Component;
+
+@Component
+public class FastApiTranscribeClient extends FastApiClient {
+
+    public FastApiResponse<JsonNode> transcribeAudio(Resource audio,
+                                                     String filename,
+                                                     String contentType,
+                                                     Integer numSpeakers) {
+        return transcribeAudio(audio, filename, contentType, numSpeakers, null, null);
+    }
+
+    public FastApiResponse<JsonNode> transcribeAudio(TranscribeRequest request) {
+        return transcribeAudio(
+                request.audio().resource(),
+                request.audio().filename(),
+                request.audio().contentType(),
+                request.numSpeakers(),
+                request.meetingId(),
+                request.projectId()
+        );
+    }
+
+    public FastApiResponse<JsonNode> transcribeAudio(Resource audio,
+                                                     String filename,
+                                                     String contentType,
+                                                     Integer numSpeakers,
+                                                     String meetingId,
+                                                     String projectId) {
+        return postMultipart(
+                FastApiInfo.TRANSCRIBE_AUDIO,
+                buildTextParts(numSpeakers, meetingId, projectId),
+                new FastApiBinaryPart("audio", audio, filename, contentType),
+                new ParameterizedTypeReference<>() {
+                }
+        );
+    }
+
+    public FastApiResponse<JsonNode> transcribeApplications(Resource audio,
+                                                            String filename,
+                                                            String contentType,
+                                                            Integer numSpeakers,
+                                                            String meetingId,
+                                                            String projectId) {
+        return postMultipart(
+                FastApiInfo.TRANSCRIBE_APPLICATIONS,
+                buildTextParts(numSpeakers, meetingId, projectId),
+                new FastApiBinaryPart("audio", audio, filename, contentType),
+                new ParameterizedTypeReference<>() {
+                }
+        );
+    }
+
+    public FastApiResponse<JsonNode> transcribeApplications(TranscribeRequest request) {
+        return transcribeApplications(
+                request.audio().resource(),
+                request.audio().filename(),
+                request.audio().contentType(),
+                request.numSpeakers(),
+                request.meetingId(),
+                request.projectId()
+        );
+    }
+
+    public FastApiResponse<TranscribeApplicationRunCreateResponse> createTranscribeApplicationRun(Resource audio,
+                                                                                                  String filename,
+                                                                                                  String contentType,
+                                                                                                  Integer numSpeakers,
+                                                                                                  String meetingId,
+                                                                                                  String projectId) {
+        return postMultipart(
+                FastApiInfo.TRANSCRIBE_APPLICATION_RUNS,
+                buildTextParts(numSpeakers, meetingId, projectId),
+                new FastApiBinaryPart("audio", audio, filename, contentType),
+                new ParameterizedTypeReference<>() {
+                }
+        );
+    }
+
+    public FastApiResponse<TranscribeApplicationRunCreateResponse> createTranscribeApplicationRun(TranscribeRequest request) {
+        return createTranscribeApplicationRun(
+                request.audio().resource(),
+                request.audio().filename(),
+                request.audio().contentType(),
+                request.numSpeakers(),
+                request.meetingId(),
+                request.projectId()
+        );
+    }
+
+    public FastApiResponse<TranscribeApplicationRunResponse> getTranscribeApplicationRun(String runId) {
+        return get(
+                FastApiInfo.TRANSCRIBE_APPLICATION_RUN_STATUS,
+                Map.of("run_id", runId),
+                new ParameterizedTypeReference<>() {
+                }
+        );
+    }
+
+    private Map<String, Object> buildTextParts(Integer numSpeakers, String meetingId, String projectId) {
+        Map<String, Object> parts = new LinkedHashMap<>();
+        if (numSpeakers != null) {
+            parts.put("num_speakers", numSpeakers);
+        }
+        if (meetingId != null) {
+            parts.put("meeting_id", meetingId);
+        }
+        if (projectId != null) {
+            parts.put("project_id", projectId);
+        }
+        return parts;
+    }
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/dto/FastApiResponse.java b/src/main/java/com/whylog/server/global/external/fast/dto/FastApiResponse.java
new file mode 100644
index 0000000..ddba741
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/dto/FastApiResponse.java
@@ -0,0 +1,13 @@
+package com.whylog.server.global.external.fast.dto;
+
+import com.fasterxml.jackson.databind.PropertyNamingStrategies;
+import com.fasterxml.jackson.databind.annotation.JsonNaming;
+
+@JsonNaming(PropertyNamingStrategies.LowerCamelCaseStrategy.class)
+public record FastApiResponse<T>(
+        Boolean isSuccess,
+        String code,
+        String message,
+        T result
+) {
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/dto/request/ChangedFile.java b/src/main/java/com/whylog/server/global/external/fast/dto/request/ChangedFile.java
new file mode 100644
index 0000000..b3f1c32
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/dto/request/ChangedFile.java
@@ -0,0 +1,12 @@
+package com.whylog.server.global.external.fast.dto.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+@Schema(description = "FastAPI 커밋 변경 파일")
+public record ChangedFile(
+        @Schema(description = "변경된 파일 경로")
+        String fileName,
+        @Schema(description = "unified diff 형식의 변경 코드")
+        String changedCode
+) {
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/dto/request/CommitAnalyzeRequest.java b/src/main/java/com/whylog/server/global/external/fast/dto/request/CommitAnalyzeRequest.java
new file mode 100644
index 0000000..5fd5810
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/dto/request/CommitAnalyzeRequest.java
@@ -0,0 +1,19 @@
+package com.whylog.server.global.external.fast.dto.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import java.util.List;
+
+@Schema(description = "FastAPI 커밋 분석 요청")
+public record CommitAnalyzeRequest(
+        @Schema(description = "커밋 ID")
+        Integer commitId,
+        @Schema(description = "Git 커밋 해시", nullable = true)
+        String commitHash,
+        @Schema(description = "Spring 레포지토리 ID")
+        Integer repositoryId,
+        @Schema(description = "커밋 메시지")
+        String message,
+        @Schema(description = "변경된 파일 목록")
+        List<ChangedFile> changedFileList
+) {
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/dto/request/MeetingAnalysisRequest.java b/src/main/java/com/whylog/server/global/external/fast/dto/request/MeetingAnalysisRequest.java
new file mode 100644
index 0000000..3b0d53c
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/dto/request/MeetingAnalysisRequest.java
@@ -0,0 +1,15 @@
+package com.whylog.server.global.external.fast.dto.request;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+@Schema(description = "FastAPI 회의 분석 요청")
+public record MeetingAnalysisRequest(
+        @Schema(description = "회의 ID(선택)", nullable = true)
+        String meetingId,
+        @Schema(description = "프로젝트 ID(선택)", nullable = true)
+        String projectId,
+        @Schema(description = "전사 세그먼트 배열")
+        JsonNode transcriptSegments
+) {
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/dto/request/TranscribeRequest.java b/src/main/java/com/whylog/server/global/external/fast/dto/request/TranscribeRequest.java
new file mode 100644
index 0000000..0edee3f
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/dto/request/TranscribeRequest.java
@@ -0,0 +1,17 @@
+package com.whylog.server.global.external.fast.dto.request;
+
+import com.whylog.server.global.external.fast.client.FastApiBinaryPart;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+@Schema(description = "FastAPI 전사 요청")
+public record TranscribeRequest(
+        @Schema(description = "전사할 오디오 파일")
+        FastApiBinaryPart audio,
+        @Schema(description = "화자 수", nullable = true)
+        Integer numSpeakers,
+        @Schema(description = "회의 ID(선택)", nullable = true)
+        String meetingId,
+        @Schema(description = "프로젝트 ID(선택)", nullable = true)
+        String projectId
+) {
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/dto/response/TranscribeApplicationRunCreateResponse.java b/src/main/java/com/whylog/server/global/external/fast/dto/response/TranscribeApplicationRunCreateResponse.java
new file mode 100644
index 0000000..6821847
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/dto/response/TranscribeApplicationRunCreateResponse.java
@@ -0,0 +1,23 @@
+package com.whylog.server.global.external.fast.dto.response;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.databind.PropertyNamingStrategies;
+import com.fasterxml.jackson.databind.annotation.JsonNaming;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+@JsonNaming(PropertyNamingStrategies.SnakeCaseStrategy.class)
+@JsonIgnoreProperties(ignoreUnknown = true)
+@Schema(description = "FastAPI 전사+회의 분석 비동기 실행 생성 응답")
+public record TranscribeApplicationRunCreateResponse(
+        @Schema(description = "비동기 실행 ID", example = "550e8400-e29b-41d4-a716-446655440000")
+        String runId,
+        @Schema(description = "실행 상태", example = "queued")
+        String status,
+        @Schema(description = "실행 단계", example = "queued")
+        String phase,
+        @Schema(description = "회의 ID", example = "meeting-123", nullable = true)
+        String meetingId,
+        @Schema(description = "프로젝트 ID", example = "project-abc", nullable = true)
+        String projectId
+) {
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/dto/response/TranscribeApplicationRunResponse.java b/src/main/java/com/whylog/server/global/external/fast/dto/response/TranscribeApplicationRunResponse.java
new file mode 100644
index 0000000..d75cc33
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/dto/response/TranscribeApplicationRunResponse.java
@@ -0,0 +1,143 @@
+package com.whylog.server.global.external.fast.dto.response;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.databind.PropertyNamingStrategies;
+import com.fasterxml.jackson.databind.annotation.JsonNaming;
+import io.swagger.v3.oas.annotations.media.Schema;
+import java.time.OffsetDateTime;
+import java.util.List;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+@Schema(description = "FastAPI 전사+회의 분석 비동기 실행 상태 조회 응답")
+public record TranscribeApplicationRunResponse(
+        @Schema(description = "비동기 실행 ID", example = "550e8400-e29b-41d4-a716-446655440000")
+        String runId,
+        @Schema(description = "실행 상태", example = "completed")
+        String status,
+        @Schema(description = "실행 단계", example = "applications_ready")
+        String phase,
+        @Schema(description = "회의 ID", example = "meeting-123", nullable = true)
+        String meetingId,
+        @Schema(description = "프로젝트 ID", example = "project-abc", nullable = true)
+        String projectId,
+        @Schema(description = "제출 시각", nullable = true)
+        OffsetDateTime submittedAt,
+        @Schema(description = "시작 시각", nullable = true)
+        OffsetDateTime startedAt,
+        @Schema(description = "종료 시각", nullable = true)
+        OffsetDateTime finishedAt,
+        @Schema(description = "실행 실패 사유", nullable = true)
+        String error,
+        @Schema(description = "최종 또는 중간 결과", nullable = true)
+        TranscribeApplicationRunResult result
+) {
+
+    @JsonNaming(PropertyNamingStrategies.SnakeCaseStrategy.class)
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    @Schema(description = "전사+회의 분석 실행 결과")
+    public record TranscribeApplicationRunResult(
+            @Schema(description = "회의 ID", example = "meeting-123", nullable = true)
+            String meetingId,
+            @Schema(description = "프로젝트 ID", example = "project-abc", nullable = true)
+            String projectId,
+            @Schema(description = "전사 세그먼트 목록", nullable = true)
+            List<TranscriptSegmentResponse> transcriptSegments,
+            @Schema(description = "회의 분석 결과", nullable = true)
+            AnalysisResultResponse analysisResult
+    ) {
+    }
+
+    @JsonNaming(PropertyNamingStrategies.SnakeCaseStrategy.class)
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    @Schema(description = "전사 세그먼트")
+    public record TranscriptSegmentResponse(
+            @Schema(description = "메시지 ID", example = "1", nullable = true)
+            Long messageId,
+            @Schema(description = "화자명", example = "Speaker 0", nullable = true)
+            String speaker,
+            @Schema(description = "시작 시각", example = "00:00:00", nullable = true)
+            String startTime,
+            @Schema(description = "종료 시각", example = "00:00:04", nullable = true)
+            String endTime,
+            @Schema(description = "전사 텍스트", example = "Swagger 에러 응답 예시가 부족합니다.", nullable = true)
+            String text,
+            @Schema(description = "최종 전사 여부", example = "true", nullable = true)
+            Boolean isFinal
+    ) {
+    }
+
+    @JsonNaming(PropertyNamingStrategies.SnakeCaseStrategy.class)
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    @Schema(description = "회의 분석 결과")
+    public record AnalysisResultResponse(
+            @Schema(description = "전체 분석 결과", nullable = true)
+            OverallAnalysisResponse overallAnalysis,
+            @Schema(description = "적용사항 목록", nullable = true)
+            List<ApplicationResponse> applications,
+            @Schema(description = "기타 언급 목록", nullable = true)
+            List<String> otherMentions
+    ) {
+    }
+
+    @JsonNaming(PropertyNamingStrategies.SnakeCaseStrategy.class)
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    @Schema(description = "전체 분석 결과")
+    public record OverallAnalysisResponse(
+            @Schema(description = "회의 정보", nullable = true)
+            MeetingInfoResponse meetingInfo,
+            @Schema(description = "토픽 목록", nullable = true)
+            List<String> topics,
+            @Schema(description = "핵심 맥락", nullable = true)
+            List<String> coreContext,
+            @Schema(description = "적용사항 제목 목록", nullable = true)
+            List<String> applicationTitles,
+            @Schema(description = "적용사항 사유 목록", nullable = true)
+            List<String> applicationReasons
+    ) {
+    }
+
+    @JsonNaming(PropertyNamingStrategies.SnakeCaseStrategy.class)
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    @Schema(description = "회의 정보")
+    public record MeetingInfoResponse(
+            @Schema(description = "회의 제목", nullable = true)
+            String title,
+            @Schema(description = "회의 목적", nullable = true)
+            String purpose,
+            @Schema(description = "회의 길이", example = "00:12:30", nullable = true)
+            String duration
+    ) {
+    }
+
+    @JsonNaming(PropertyNamingStrategies.SnakeCaseStrategy.class)
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    @Schema(description = "적용사항")
+    public record ApplicationResponse(
+            @Schema(description = "적용사항 ID", example = "null", nullable = true)
+            Long applicationId,
+            @Schema(description = "적용사항 제목", nullable = true)
+            String applicationTitle,
+            @Schema(description = "적용사항 사유 목록", nullable = true)
+            List<String> applicationReasons,
+            @Schema(description = "타임라인", nullable = true)
+            List<TimelineResponse> timeline
+    ) {
+    }
+
+    @JsonNaming(PropertyNamingStrategies.SnakeCaseStrategy.class)
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    @Schema(description = "적용사항 타임라인")
+    public record TimelineResponse(
+            @Schema(description = "타임스탬프", example = "00:03:12", nullable = true)
+            String timestamp,
+            @Schema(description = "단계", example = "이슈제기", nullable = true)
+            String step,
+            @Schema(description = "화자 ID", example = "Speaker 0", nullable = true)
+            String speakerId,
+            @Schema(description = "내용", nullable = true)
+            String content,
+            @Schema(description = "원문 발화", nullable = true)
+            String utterance
+    ) {
+    }
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/exception/FastApiErrorCode.java b/src/main/java/com/whylog/server/global/external/fast/exception/FastApiErrorCode.java
new file mode 100644
index 0000000..1c35008
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/exception/FastApiErrorCode.java
@@ -0,0 +1,39 @@
+package com.whylog.server.global.external.fast.exception;
+
+import com.whylog.server.global.apiPayload.code.BaseErrorCode;
+import com.whylog.server.global.apiPayload.code.ErrorReasonDTO;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+
+@Getter
+@RequiredArgsConstructor
+public enum FastApiErrorCode implements BaseErrorCode {
+
+    FAST_API_REQUEST_FAILED(HttpStatus.INTERNAL_SERVER_ERROR, "FAST_API_500_1", "FastAPI 요청에 실패했습니다."),
+    FAST_API_RESPONSE_EMPTY(HttpStatus.INTERNAL_SERVER_ERROR, "FAST_API_500_2", "FastAPI 응답이 비어있습니다."),
+    FAST_API_INVALID_REQUEST_BODY(HttpStatus.INTERNAL_SERVER_ERROR, "FAST_API_500_3", "FastAPI 요청 본문 형식이 올바르지 않습니다.");
+
+    private final HttpStatus httpStatus;
+    private final String code;
+    private final String message;
+
+    @Override
+    public ErrorReasonDTO getReason() {
+        return ErrorReasonDTO.builder()
+                .isSuccess(false)
+                .code(code)
+                .message(message)
+                .build();
+    }
+
+    @Override
+    public ErrorReasonDTO getReasonHttpStatus() {
+        return ErrorReasonDTO.builder()
+                .httpStatus(httpStatus)
+                .isSuccess(false)
+                .code(code)
+                .message(message)
+                .build();
+    }
+}
diff --git a/src/main/java/com/whylog/server/global/external/fast/exception/FastApiException.java b/src/main/java/com/whylog/server/global/external/fast/exception/FastApiException.java
new file mode 100644
index 0000000..3cfb3c9
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/fast/exception/FastApiException.java
@@ -0,0 +1,15 @@
+package com.whylog.server.global.external.fast.exception;
+
+import com.whylog.server.global.apiPayload.exception.GeneralException;
+
+public class FastApiException extends GeneralException {
+
+    public FastApiException(FastApiErrorCode errorCode) {
+        super(errorCode);
+    }
+
+    public FastApiException(FastApiErrorCode errorCode, Throwable cause) {
+        super(errorCode);
+        initCause(cause);
+    }
+}
diff --git a/src/main/java/com/whylog/server/global/external/livekit/LiveKitEgressClient.java b/src/main/java/com/whylog/server/global/external/livekit/LiveKitEgressClient.java
new file mode 100644
index 0000000..8010dd4
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/external/livekit/LiveKitEgressClient.java
@@ -0,0 +1,131 @@
+package com.whylog.server.global.external.livekit;
+
+import com.whylog.server.global.util.json.JsonConverter;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+import org.springframework.web.client.RestClient;
+import org.springframework.web.client.HttpClientErrorException;
+
+import java.net.URI;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class LiveKitEgressClient {
+
+    @Value("${livekit.url}")
+    private String liveKitUrl;
+
+    @Value("${aws.s3.bucket}")
+    private String bucket;
+
+    @Value("${aws.s3.region}")
+    private String region;
+
+    @Value("${aws.s3.access-key}")
+    private String accessKey;
+
+    @Value("${aws.s3.secret-key}")
+    private String secretKey;
+
+    @Value("${aws.s3.endpoint:}")
+    private String s3Endpoint;
+
+    @Value("${aws.s3.force-path-style:false}")
+    private boolean forcePathStyle;
+
+    private final RestClient restClient = RestClient.create();
+
+    public String startRoomAudioEgress(String egressToken, String roomName, String recordingKey) {
+        Map<String, Object> request = new LinkedHashMap<>();
+        request.put("room_name", roomName);
+        request.put("audio_only", true);
+        request.put("file_outputs", List.of(buildFileOutput(recordingKey)));
+
+        Map<String, Object> response = post("/twirp/livekit.Egress/StartRoomCompositeEgress", egressToken, request);
+        Object egressId = response.get("egress_id");
+        if (egressId == null) {
+            throw new IllegalStateException("LiveKit egress response did not include egress_id");
+        }
+        return egressId.toString();
+    }
+
+    public void createRoom(String roomCreateToken, String roomName) {
+        Map<String, Object> request = new LinkedHashMap<>();
+        request.put("name", roomName);
+
+        try {
+            post("/twirp/livekit.RoomService/CreateRoom", roomCreateToken, request);
+        } catch (HttpClientErrorException.Conflict e) {
+            log.info("LiveKit room already exists: roomName={}", roomName);
+        }
+    }
+
+    public void stopEgress(String egressToken, String egressId) {
+        Map<String, Object> request = Map.of("egress_id", egressId);
+        post("/twirp/livekit.Egress/StopEgress", egressToken, request);
+    }
+
+    @SuppressWarnings("unchecked")
+    private Map<String, Object> post(String path, String egressToken, Map<String, Object> request) {
+        String apiBaseUrl = toHttpsBaseUrl(liveKitUrl);
+        URI uri = URI.create(apiBaseUrl + path);
+
+        Object body = request;
+        String requestJson = JsonConverter.toJson(request);
+        log.info("LiveKit egress request: {}", requestJson);
+
+        Map<String, Object> response = restClient.post()
+                .uri(uri)
+                .contentType(MediaType.APPLICATION_JSON)
+                .header("Authorization", "Bearer " + egressToken)
+                .body(body)
+                .retrieve()
+                .body(Map.class);
+
+        if (response == null) {
+            throw new IllegalStateException("LiveKit egress response is empty");
+        }
+
+        log.info("LiveKit egress response: {}", JsonConverter.toJson(response));
+        return response;
+    }
+
+    private Map<String, Object> buildFileOutput(String recordingKey) {
+        Map<String, Object> s3 = new LinkedHashMap<>();
+        s3.put("access_key", accessKey);
+        s3.put("secret", secretKey);
+        s3.put("bucket", bucket);
+        s3.put("region", region);
+        if (StringUtils.hasText(s3Endpoint)) {
+            s3.put("endpoint", s3Endpoint);
+        }
+        s3.put("force_path_style", forcePathStyle);
+
+        Map<String, Object> fileOutput = new LinkedHashMap<>();
+        fileOutput.put("filepath", recordingKey);
+        fileOutput.put("s3", s3);
+        return fileOutput;
+    }
+
+    private String toHttpsBaseUrl(String wsUrl) {
+        if (wsUrl.startsWith("wss://")) {
+            return "https://" + wsUrl.substring("wss://".length());
+        }
+        if (wsUrl.startsWith("ws://")) {
+            return "http://" + wsUrl.substring("ws://".length());
+        }
+        if (wsUrl.startsWith("https://") || wsUrl.startsWith("http://")) {
+            return wsUrl;
+        }
+        return "https://" + wsUrl;
+    }
+
+}
diff --git a/src/main/java/com/whylog/server/global/external/s3/S3Client.java b/src/main/java/com/whylog/server/global/external/s3/S3Client.java
index d1d5a32..d4cb5b1 100644
--- a/src/main/java/com/whylog/server/global/external/s3/S3Client.java
+++ b/src/main/java/com/whylog/server/global/external/s3/S3Client.java
@@ -3,6 +3,7 @@
 import java.io.IOException;
 import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
+import java.time.Duration;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
@@ -11,8 +12,13 @@
 import org.springframework.web.multipart.MultipartFile;
 import software.amazon.awssdk.core.exception.SdkClientException;
 import software.amazon.awssdk.core.sync.RequestBody;
+import software.amazon.awssdk.services.s3.model.HeadObjectRequest;
 import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;
 import software.amazon.awssdk.services.s3.model.PutObjectRequest;
+import software.amazon.awssdk.services.s3.model.GetObjectRequest;
+import software.amazon.awssdk.services.s3.presigner.S3Presigner;
+import software.amazon.awssdk.services.s3.presigner.model.GetObjectPresignRequest;
+import software.amazon.awssdk.services.s3.presigner.model.PresignedGetObjectRequest;
 
 @Slf4j
 @Component
@@ -20,6 +26,7 @@
 public class S3Client {
 
     private final software.amazon.awssdk.services.s3.S3Client s3Client;
+    private final S3Presigner s3Presigner;
 
     @Value("${aws.s3.bucket}")
     private String bucket;
@@ -75,6 +82,50 @@ public String getFileUrl(String fileName) {
         return "https://" + bucket + ".s3." + region + ".amazonaws.com/" + encodedFileName;
     }
 
+    public String getPresignedFileUrl(String fileName, Duration duration, String responseContentType) {
+        if (!StringUtils.hasText(fileName)) {
+            return null;
+        }
+
+        GetObjectRequest.Builder getObjectRequest = GetObjectRequest.builder()
+                .bucket(bucket)
+                .key(fileName);
+
+        if (StringUtils.hasText(responseContentType)) {
+            getObjectRequest.responseContentType(responseContentType);
+        }
+
+        GetObjectPresignRequest presignRequest = GetObjectPresignRequest.builder()
+                .signatureDuration(duration)
+                .getObjectRequest(getObjectRequest.build())
+                .build();
+
+        PresignedGetObjectRequest presignedRequest = s3Presigner.presignGetObject(presignRequest);
+        return presignedRequest.url().toString();
+    }
+
+    public boolean exists(String fileName) {
+        if (!StringUtils.hasText(fileName)) {
+            return false;
+        }
+
+        try {
+            s3Client.headObject(HeadObjectRequest.builder()
+                    .bucket(bucket)
+                    .key(fileName)
+                    .build());
+            return true;
+        } catch (software.amazon.awssdk.services.s3.model.S3Exception e) {
+            if (e.statusCode() == 404 || e.statusCode() == 403) {
+                return false;
+            }
+            throw e;
+        } catch (SdkClientException e) {
+            log.error("S3 존재 확인 에러 발생: {}", e.getMessage());
+            return false;
+        }
+    }
+
     public void deleteFile(String fileName) {
         if (!StringUtils.hasText(fileName)) {
             return;
diff --git a/src/main/java/com/whylog/server/global/util/json/JsonConverter.java b/src/main/java/com/whylog/server/global/util/json/JsonConverter.java
index 50c0349..15d241f 100644
--- a/src/main/java/com/whylog/server/global/util/json/JsonConverter.java
+++ b/src/main/java/com/whylog/server/global/util/json/JsonConverter.java
@@ -2,11 +2,14 @@
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.PropertyNamingStrategies;
 import org.springframework.web.socket.TextMessage;
 
 public class JsonConverter {
 
-    private static final ObjectMapper objectMapper = new ObjectMapper().findAndRegisterModules();
+    private static final ObjectMapper objectMapper = new ObjectMapper()
+            .findAndRegisterModules()
+            .setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
 
     // keyword 없을 때
     public static String toJson(Object value, String keyword) {
diff --git a/src/main/java/com/whylog/server/global/util/json/StringListJsonConverter.java b/src/main/java/com/whylog/server/global/util/json/StringListJsonConverter.java
new file mode 100644
index 0000000..67ffc00
--- /dev/null
+++ b/src/main/java/com/whylog/server/global/util/json/StringListJsonConverter.java
@@ -0,0 +1,40 @@
+package com.whylog.server.global.util.json;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.persistence.AttributeConverter;
+import jakarta.persistence.Converter;
+import java.util.List;
+
+@Converter
+public class StringListJsonConverter implements AttributeConverter<List<String>, String> {
+
+    private static final ObjectMapper objectMapper = new ObjectMapper().findAndRegisterModules();
+
+    @Override
+    public String convertToDatabaseColumn(List<String> attribute) {
+        if (attribute == null) {
+            return null;
+        }
+
+        try {
+            return objectMapper.writeValueAsString(attribute);
+        } catch (JsonProcessingException e) {
+            throw new IllegalStateException("List<String> to JSON 변환 실패", e);
+        }
+    }
+
+    @Override
+    public List<String> convertToEntityAttribute(String dbData) {
+        if (dbData == null || dbData.isBlank()) {
+            return null;
+        }
+
+        try {
+            return objectMapper.readValue(dbData, new TypeReference<List<String>>() {});
+        } catch (JsonProcessingException e) {
+            throw new IllegalStateException("JSON to List<String> 변환 실패", e);
+        }
+    }
+}
diff --git a/src/main/resources/application.yaml b/src/main/resources/application.yaml
index 90aab4c..b9ec353 100644
--- a/src/main/resources/application.yaml
+++ b/src/main/resources/application.yaml
@@ -49,7 +49,6 @@ livekit:
   url: ${LIVEKIT_URL:wss://example.livekit.invalid}
   api-key: ${LIVEKIT_API_KEY:devkey}
   api-secret: ${LIVEKIT_API_SECRET:01234567890123456789012345678901}
-  token-expire-time: ${LIVEKIT_TOKEN_EXPIRE_TIME:3600000}
 
 github:
   token:
@@ -61,3 +60,12 @@ aws:
     region: ${AWS_REGION:ap-northeast-2}
     access-key: ${AWS_S3_ACCESS_KEY}
     secret-key: ${AWS_S3_SECRET_KEY}
+
+audio:
+  # Ubuntu: /usr/bin/ffprobe 또는 PATH의 ffprobe
+  # macOS(Homebrew): /opt/homebrew/bin/ffprobe
+  ffprobe-command: ${AUDIO_FFPROBE_COMMAND:/opt/homebrew/bin/ffprobe}
+
+fast:
+  api:
+    base-url: ${FAST_API_BASE_URL}