From 7f199e6ae7db5e297dfc53cc7fc8a724dd90de55 Mon Sep 17 00:00:00 2001 From: lunaticbum Date: Tue, 17 Nov 2026 14:40:15 +0900 Subject: [PATCH] fix(core): Phase 1 critical stability and memory optimizations - Lazy initialize RagService.embeddingModel to prevent fixed port mismatch before PortFinder executes - Replace global pkill in LlamaServerManager with targeted port/PID-based cleanup - Remove redundant errorStream reader thread in LlamaServerManager and ensure descendant process destruction on stop - Convert DartCodeManager XML parsing from DOM to StAX streaming to eliminate high heap memory consumption (300MB -> few MB) - Make shared collections in DynamicNewsScraper and AutoTradingManager thread-safe (ConcurrentHashMap, Collections.synchronizedList) - Reduce KisTradeService Ktor logging level from ALL to HEADERS/NONE to prevent high I/O overhead and credential exposure - Add ARCHITECTURE.md and todo.md system documentation --- ARCHITECTURE.md | 241 ++++++++++++++++++ src/main/kotlin/network/DartCodeManager.kt | 109 ++++---- src/main/kotlin/network/KisTradeService.kt | 4 +- src/main/kotlin/network/RagService.kt | 215 +++++----------- src/main/kotlin/service/AutoTradingManager.kt | 10 +- src/main/kotlin/service/DynamicNewsScraper.kt | 3 +- src/main/kotlin/service/LlamaServerManager.kt | 157 +++++++----- todo.md | 235 +++++++++++++++++ 8 files changed, 695 insertions(+), 279 deletions(-) create mode 100644 ARCHITECTURE.md create mode 100644 todo.md diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md new file mode 100644 index 0000000..7f87da7 --- /dev/null +++ b/ARCHITECTURE.md @@ -0,0 +1,241 @@ +# AutoTradeAI 시스템 아키텍처 (ARCHITECTURE.md) + +## 1. 개요 (Overview) + +**AutoTradeAI**는 한국투자증권(KIS) Open API, 금융감독원 전자공시시스템(DART), 네이버 뉴스 검색, 그리고 로컬 LLM(대형 언어 모델) 및 벡터 RAG(검색 증강 생성) 기술을 결합한 **하이브리드 퀀트/AI 자동 주식 매매 시스템**입니다. + +데스크톱 환경(Compose for Desktop)에서 단독 실행되며, 온디바이스(On-Device) 로컬 추론 엔진(`llama-server` / `Ollama`)을 통해 외부 클라우드 비용 없이 실시간 재무 분석, 기술적 퀀트 지표 분석, 뉴스 감성 분석을 종합하여 매매 결정을 내립니다. + +--- + +## 2. 전체 시스템 아키텍처 다이어그램 + +```mermaid +flowchart TD + subgraph UI_Layer ["프레젠테이션 계층 (Compose for Desktop)"] + UI_Settings["SettingsScreen\n(API 키, 계좌, 파라미터 설정)"] + UI_Decision["TradingDecisionLog\n(실시간 분석 로그, 매수/매도 신호)"] + UI_Dashboard["DashboardScreen / CandleChart\n(차트 및 잔고 모니터링)"] + UI_Tray["System Tray / Sleep Preventer\n(백그라운드 지속 구동)"] + end + + subgraph Service_Engine ["서비스 & 오케스트레이션 계층"] + ATM["AutoTradingManager\n(스케줄링, 발굴 루프, 매매 집행)"] + Watchdog["Watchdog Timer\n(루프 정체 감지 및 자동 복구)"] + BrowserMgr["BrowserManager & SafeScraper\n(Playwright 동적 기사 크롤링)"] + LlamaMgr["LlamaServerManager\n(로컬 llama-server 프로세스 수명주기 관리)"] + end + + subgraph Analyzer_Engine ["분석 & 퀀트 계층"] + TechAnlz["TechnicalAnalyzer\n(RSI, MFI, 볼린저밴드, MTF, 반등예측)"] + FinAnlz["FinancialAnalyzer\n(DART 재무제표, 부채/당좌/ROE, 안전벨트)"] + RiskMgr["RiskManager\n(투자경고/정리매매/관리종목 필터)"] + AdvAsst["AdvancedTradeAssistant\n(VWAP, 볼린저 하단 타점 검증)"] + end + + subgraph AI_RAG_Layer ["로컬 AI & RAG 계층"] + RAG["RagService\n(LangChain4j + Lucene MMapDirectory)"] + LocalLLM["llama-server / Ollama\n(Qwen / Llama-3 온디바이스 추론)"] + EmbedModel["BGE-M3 임베딩 모델\n(벡터 임베딩 생성)"] + end + + subgraph Network_Integration ["네트워크 & 외부 연동 계층"] + KisAuth["KisAuthService\n(OAuth2 토큰 관리)"] + KisTrade["KisTradeService\n(국내/해외 시세, 캔들, 주문, 잔고)"] + KisWS["KisWebSocketManager\n(실시간 체결 통보 / 호가 AES 복호화)"] + DartMgr["DartCodeManager / NewsService\n(DART 공시 API, 네이버 뉴스 API)"] + Telegram["Telegram Notifier\n(매매 및 시스템 알림)"] + end + + subgraph Data_Storage ["영속성 & 스토리지 계층"] + H2_Main["H2 Database: autotrade_db\n(설정, 감시종목, 거래로그)"] + H2_Report["H2 Database: trade_report\n(자산 스냅샷, 일일 매매 리포트)"] + Lucene_DB["Lucene Index: db/lucene_idx\n(뉴스 벡터 임베딩 저장소)"] + JSON_Config["trade_config.json / stocks_universe.json\n(세부 파라미터, 종목 유니버스)"] + end + + %% 연결 관계 + UI_Settings --> H2_Main + UI_Decision --> ATM + ATM --> Watchdog + ATM --> KisTrade + ATM --> KisWS + ATM --> TechAnlz + ATM --> FinAnlz + ATM --> RiskMgr + ATM --> AdvAsst + ATM --> RAG + + FinAnlz --> DartMgr + RAG --> BrowserMgr + RAG --> LocalLLM + RAG --> EmbedModel + RAG --> Lucene_DB + + BrowserMgr --> DartMgr + LlamaMgr --> LocalLLM + + KisTrade --> KisAuth + ATM --> H2_Main + ATM --> H2_Report + ATM --> Telegram +``` + +--- + +## 3. 핵심 모듈별 역할 및 구성 + +### 3.1. 프레젠테이션 계층 (Presentation Layer) +- **Compose for Desktop (`org.jetbrains.compose`)**: + - `Main.kt`: 데스크톱 앱 엔트리포인트. OS 아키텍처에 따른 바이너리 실행 권한(macOS `xattr`, `codesign`, `spctl`) 해제 및 포트 동적 할당(`PortFinder`). + - `SettingsScreen.kt`: 실전/모의투자 API 키, 계좌번호, DART 키, 네이버 API 키, AI 가중치, 손익절 임계치 설정. + - `TradingDecisionLog.kt`: 현재 감시 및 AI 분석 대상 종목의 실시간 점수(기술/재무/뉴스/합성), 매수/매도 사유 및 로그 출력. + - `DashboardScreen.kt`, `CandleChart.kt`: 보유 종목 현황 및 차트 렌더링. + - `SystemSleepPreventer.kt`: 장중 운영체제 화면 꺼짐 및 대기 모드 진입 방지 (`caffeinate` / Windows API). + +### 3.2. 오케스트레이션 및 매매 엔진 (Service Layer) +- **`AutoTradingManager.kt`**: + - 전체 자동매매 라이프사이클을 통제하는 싱글톤 오케스트레이터. + - 백그라운드 스케줄러 (`startBackgroundScheduler`): 영업일 확인, 장 시작 전(08:00~08:55) 시스템 초기화, 토큰 갱신, 장 마감(15:30~) 후 자원 정리. + - 발굴 루프 (`runDiscoveryLoop`, `executeMarketLoop`): 후보군 수집 -> 필터링 -> 개별 분석 -> 주문 실행 -> 실시간 모니터링. + - 워치독(`Watchdog`): 루프 정체(Stuck) 감지 시 자동 재기동. + - 매도 스케줄러 (`sellSchedule`): 정규장 및 시간외 단일가 분할 매도, 트레일링 스탑, 장 마감 전 미체결 취소. + - 물타기(평단가 낮추기) 우선순위 큐 관리: 손실 폭이 큰 종목에 대해 기술적 바닥 확인 후 선제적 탈출 분석 실행. +- **`LlamaServerManager.kt`**: + - 시스템 CPU 코어 수 및 GPU(NVIDIA CUDA / Apple Silicon Metal / Vulkan) 가속을 자동 감지하여 적정 스레드 및 레이어로 `llama-server` 데몬 프로세스 구동. + - 외부 Ollama(Port 11434) 활성화 여부를 체크하여 이미 가동 중이면 공유 모드로 자동 전환. + +### 3.3. 분석 및 퀀트 계층 (Analyzer Layer) +- **`TechnicalAnalyzer.kt`**: + - 멀티 타임프레임(30분봉, 일봉, 주봉, 월봉) 통합 분석. + - RSI(상대강도지수), MFI(자금흐름지수), OBV, ATR 계산. + - 동적 반등 주기(Dynamic Rebound Period) 및 진폭 통계 산출. + - 변동성 예측(Volatility Forecast) 및 지하실/낙폭과대 바닥 예측(`predictDropBottom`). + - 브레이크 및 캔들 반전 확인(`checkBrakeAndReversal`). +- **`FinancialAnalyzer.kt` & `FinancialMapper.kt`**: + - DART Open API 응답(재무상태표, 손익계산서) 텍스트를 구조화된 `FinancialStatement`로 파싱. + - 재무 안전벨트(`isSafetyBeltMet`): 자본잠식률, 부채비율, 당좌비율, 적자 지속 여부 판별. + - 재무 건전성 및 턴어라운드 점수 산출 (0~100점). +- **`RiskManager.kt`**: + - KIS 실시간 시세 메타데이터를 기반으로 거래정지, 임시정지, 정리매매, 관리종목, 투자유의, 단기과열, 시장경고 종목 사전 원천 차단. +- **`AdvancedTradeAssistant.kt`**: + - 투자 등급별 세부 타점 검증: 초단타 등급(VWAP 상회 여부), 눌림목 스윙 등급(볼린저 밴드 하단선 터치 여부)을 통한 최종 승인/거절. + +### 3.4. AI 및 RAG 계층 (AI & RAG Layer) +- **`RagService.kt`**: + - **LangChain4j** 프레임워크와 **Lucene MMapDirectory** 기반 온디바이스 RAG 파이프라인. + - 뉴스 기사 텍스트를 문단 및 500자 단위로 청킹하여 BGE-M3 임베딩 모델로 벡터화 후 인덱싱. + - 기업명 및 종목코드로 메타데이터 필터링 검색 수행. + - 로컬 LLM API (`/v1/chat/completions`) 호출: 시스템 프롬프트 및 Few-shot JSON Schema 제약을 통해 뉴스 호재/악재 점수(0~100점)와 요약 사유를 구조화된 JSON으로 추출. + - 4대 영역 가중치 합성: + $$\text{FinalConfidence} = (\text{FinScore} \times 0.25) + (\text{TechScore} \times 0.25) + (\text{NewsScore} \times 0.30) + (\text{SystemScore} \times 0.20)$$ + - 산출된 확신도에 따라 투자 등급(`LEVEL_0` ~ `LEVEL_5`) 최종 매핑. +- **`DynamicNewsScraper.kt` & `SafeScraper.kt`**: + - **Playwright** Headless Chromium 기반 동적 뉴스 본문 스크래핑. + - 스마트 DOM 분석(광고, 네비게이션, 기자 정보 제거 및 본문 텍스트 밀도 기반 추출). + - 동시성 제어(`Semaphore`) 및 유휴 시간 브라우저 인스턴스 자동 해제(`closeIfIdle`). + +### 3.5. 네트워크 및 거래 연동 계층 (Network Layer) +- **`KisAuthService.kt`**: KIS OAuth2 Access Token 발급 및 자동 갱신. +- **`KisTradeService.kt`**: Ktor Client(CIO) 기반 KIS REST API 통신 (국내/해외 통합 잔고, 차트 캔들 데이터, 현재가, 신규 주문/취소 주문, 미체결 조회). +- **`KisWebSocketManager.kt`**: + - 실시간 주식 호가/체결가 수신 (`H0STCNT0`). + - 실시간 계좌 체결 통보 수신 (`H0STCNI0`) 및 AES-128/256 복호화 처리. + - 핑퐁(PINGPONG) 하트비트 유지 및 자동 재연결 로직. +- **`DartCodeManager.kt`**: + - DART Open API로부터 전체 법인 고유번호 XML(`CORPCODE.xml`)을 수신하여 6자리 주식코드와 8자리 DART 법인코드 간 1:1 매핑 테이블 구축. + +### 3.6. 데이터베이스 및 리포팅 (Storage Layer) +- **`DatabaseFactory.kt` (Exposed ORM)**: + - `autotrade_db` (H2): `app_config` (설정), `auto_trades` (감시 주문), `trade_logs` (거래 기록), `holiday_cache` (휴장일). + - `trade_report` (H2): `AssetSnapshotTable`, `TradeHistoryTable`, `ExecutionDetailsTable`. +- **`LocalReportGenerator.kt` & `TradingReportManager.kt`**: + - 당일 체결 내역, 실현 손익, 포트폴리오 자산 변동 그래프를 포함한 단독 HTML 리포트 자동 생성. + +--- + +## 4. 전체 엔드-투-엔드 매매 데이터 흐름 (Execution Lifecycle) + +``` +[08:00 ~ 08:50] 시스템 기동 및 사전 준비 + │ + ├─ 1. 영업일 및 휴장 여부 확인 (chk-holiday API 및 캐시) + ├─ 2. KIS OAuth 토큰 발급 (시세용/매매용) & 웹소켓 키 발급 + ├─ 3. DART 기업코드 매핑 데이터 초기화 + ├─ 4. 로컬 llama-server (LLM & 임베딩) 데몬 가동 및 헬스체크 + └─ 5. KIS 웹소켓 연결 (실시간 체결 통보 대기) + +[08:55 ~ 15:10] 정규장 자동 발굴 및 매매 루프 (Discovery & Trading Loop) + │ + ├─ 1. 통합 잔고 및 미체결 주문 동기화 + │ └─ 기존 미체결 매수 주문 시간 경과 시 자동 취소 + │ + ├─ 2. 분석 대상 후보군(Universe) 취합 + │ ├─ stocks_universe.json 기본 유니버스 + │ ├─ KIS 실시간 거래량/상승률/신고가 상위 랭킹 API + │ └─ [최우선] 기존 보유 종목 중 -15% 이하 낙폭과대 종목 (물타기 탈출 대상) + │ + ├─ 3. 1차 관문 (Lightweight Filtering) + │ ├─ 당일 등락률 필터 (예: -15% ~ +15% 박스권) + │ ├─ RiskManager 위험 종목 배제 (거래정지, 관리종목, 투자주의, 단기과열) + │ └─ 재무 불량 캐시(isSafetyBeltStockCodes) 종목 즉시 패스 + │ + ├─ 4. 2차 관문: 퀀트 & 멀티타임프레임 기술적 분석 + │ ├─ 일봉/주봉/월봉/30분봉 수집 + │ ├─ 동적 반등 주기 및 진폭 검증 (주봉 2주 내 회복력 확인) + │ ├─ 지하실 하락 여력 마진 및 캔들 브레이크 확인 + │ └─ 복합 기술점수(compositeScore) 기준치 미달 시 조기 탈락 + │ + ├─ 5. 3차 관문: DART 재무 & 뉴스 RAG + LLM 추론 + │ ├─ DART 주요 계정 조회 -> 안전벨트 요건(부채/당좌/잠식) 미달 시 탈락 + │ ├─ 네이버 뉴스 API 검색 -> 1시간 내 신규 기사 필요 시 Playwright 스크래핑 + │ ├─ BGE-M3 임베딩 -> Lucene 인덱싱 및 유사도 검색 + │ └─ 로컬 LLM 호출 -> 뉴스 호/악재 점수 및 사유 생성 + │ + ├─ 6. 4차 관문: 종합 점수 산정 및 타점 승인 + │ ├─ 가중합산 확신도 계산 (최소 점수 이상 시 통과) + │ ├─ 투자 등급 매핑 (LEVEL 1 ~ 5) + │ └─ AdvancedTradeAssistant 검증 (VWAP 상회 / 볼린저 하단 타점) + │ + ├─ 7. 매수 주문 집행 (Order Placement) + │ ├─ 등급별 배정 비율 및 예산에 따른 주문 수량/호가 계산 + │ ├─ KIS postOrder 전송 (PENDING_BUY 상태로 DB 등록) + │ └─ 텔레그램 매수 알림 발송 + │ + └─ 8. 실시간 모니터링 & 매도 스케줄러 (Sell Scheduler) + ├─ 웹소켓 체결 통보 수신 -> MONITORING 상태로 전환 + ├─ 목표 익절률 도달 시 분할 매도 주문 (KRX / 대체거래소 NXT) + ├─ 손절 조건 충족 시 시장가/현재가 손절 집행 + └─ 주기적 미체결 취소 및 동기화 + +[15:10 ~ 18:00] 장 마감 후 처리 및 리포트 + │ + ├─ 1. 당일 포지션 청산 (필요 시 당일 청산 옵션 수행) + ├─ 2. 시간외 단일가 매도 스케줄링 (16:00 ~ 18:00) + ├─ 3. 자산 스냅샷 기록 및 일일 HTML 매매 리포트 생성 + └─ 4. 자원 정리 (브라우저 종료, llama-server 종료, 웹소켓 세션 종료, 화면 대기) +``` + +--- + +## 5. 사용 기술 스택 총괄표 + +| 분류 | 기술 / 라이브러리 | 버전 | 주요 용도 | +| :--- | :--- | :--- | :--- | +| **Language** | Kotlin | 2.0.0 | 전체 프로젝트 개발 언어 | +| **Runtime** | OpenJDK (JVM Toolchain) | 17 | 실행 환경 | +| **GUI Framework** | Jetpack Compose for Desktop | 1.6.11 | 멀티플랫폼 데스크톱 UI (화면, 트레이) | +| **Concurrency** | Kotlinx Coroutines | 1.8.1 | 비동기 파이프라인, 코루틴 스코프, 채널 | +| **HTTP Client** | Ktor Client (CIO, OkHttp) | 2.3.11 | 증권사 REST API, DART, 네이버 API 연동 | +| **WebSocket** | Ktor WebSockets | 2.3.11 | 실시간 시세 및 체결 통보 양방향 통신 | +| **Web Scraping** | Microsoft Playwright | 1.57.0 | 헤드리스 Chromium 기반 실시간 뉴스 동적 크롤링 | +| **Database** | Exposed Framework | 0.50.1 | 코틀린 SQL ORM (DAO, JDBC) | +| **Local Storage** | H2 Database | 2.2.224 | 내장 파일 기반 관계형 DB (`autotrade_db`, `trade_report`) | +| **Vector DB** | Apache Lucene | 9.x | MMapDirectory 기반 온디스크 벡터 인덱스 | +| **AI Framework** | LangChain4j | 1.10.0 | 로컬 LLM 오케스트레이션, OpenAI 호환 클라이언트 | +| **Local LLM Engine**| llama.cpp (`llama-server`) | 최신 바이너리 | 온디바이스 GGUF 모델 추론 데몬 (Apple Metal, Vulkan) | +| **외부 LLM 지원** | Ollama | - | 외부 11434 포트 자동 우회 연동 지원 | +| **Cryptography** | Java Cryptography (JCA) | Built-in | AES-128/256-CBC 실시간 체결 데이터 복호화 | +| **Serialization**| Kotlinx Serialization / Gson | 2.0.0 / 2.x | JSON 데이터 파싱 및 직렬화 | +| **Logging** | SLF4J / Logback Classic | 1.4.11 | 통합 로깅 | +| **Reporting** | Standalone HTML/CSS Generator | 자체 구현 | 일일 매매 결산 리포트 산출 | diff --git a/src/main/kotlin/network/DartCodeManager.kt b/src/main/kotlin/network/DartCodeManager.kt index bcc37d5..f494393 100644 --- a/src/main/kotlin/network/DartCodeManager.kt +++ b/src/main/kotlin/network/DartCodeManager.kt @@ -13,8 +13,10 @@ import model.RankingStock import service.AutoTradingManager import java.io.ByteArrayInputStream import java.io.File +import java.util.concurrent.ConcurrentHashMap import java.util.zip.ZipInputStream -import javax.xml.parsers.DocumentBuilderFactory +import javax.xml.stream.XMLInputFactory +import javax.xml.stream.XMLStreamConstants import kotlinx.serialization.encodeToString // 추가 필요 import java.nio.charset.Charset @@ -138,97 +140,88 @@ data class CorpInfo( var stockName : String = "", ) object DartCodeManager { - private val corpCodeMap = mutableMapOf() - private var DART_API_KEY = KisSession.config.dAppKey // 지범님의 API 키 입력 + private val corpCodeMap = ConcurrentHashMap() + private val DART_API_KEY: String + get() = KisSession.config.dAppKey private fun saveXmlDebugFile(xmlBytes: ByteArray) { try { val debugFile = java.io.File("debug_CORPCODE.xml") debugFile.writeBytes(xmlBytes) println("💾 [디버그] XML 파일 저장 완료: ${debugFile.absolutePath}") - // M3 Pro 환경에서는 파일 쓰기가 거의 즉시 완료됩니다. } catch (e: Exception) { println("⚠️ [디버그] 파일 저장 실패: ${e.message}") } } -// suspend fun fetchKrxData(client: HttpClient) { -// val url = "https://data.krx.co.kr/comm/bldAttendant/getJsonData.cmd" -// -// val response: HttpResponse = client.post(url) { -// // Headers 설정 -// header(HttpHeaders.Accept, "application/json, text/javascript, */*; q=0.01") -// header(HttpHeaders.AcceptLanguage, "en-US,en;q=0.9,ko-KR;q=0.8,ko;q=0.7") -// header("X-Requested-With", "XMLHttpRequest") -// header(HttpHeaders.Referrer, "https://data.krx.co.kr/contents/MDC/MDI/mdiLoader/index.cmd?menuId=MDC0302") -// header(HttpHeaders.UserAgent, "Mozilla/5.0 (Linux; Android) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36") -// -// // Body 설정 (application/x-www-form-urlencoded) -// setBody(FormDataContent(Parameters.build { -// append("bld", "dbms/MDC/EASY/ranking/MDCEASY01601") -// append("locale", "ko_KR") -// append("mktId", "ALL") -// append("itmTpCd3", "2") -// append("itmTpCd2", "1") -// append("strtDd", "20250402") -// append("endDd", "20260402") -// append("stkprcTpCd", "Y") -// append("share", "1") -// append("money", "1") -// append("csvxls_isNo", "false") -// })) -// } -// -// val responseBody = response.bodyAsText() -// println(responseBody) -// } - /** - * 앱 실행 시 호출하여 매핑 테이블 업데이트 + * 앱 실행 시 호출하여 매핑 테이블 업데이트 (StAX 스트리밍으로 OOM 방지 및 메모리 최소화) */ suspend fun updateCorpCodes(client: HttpClient) { println("📂 [DART] 법인코드 매핑 데이터 업데이트 시작...") try { - val url = "https://opendart.fss.or.kr/api/corpCode.xml?crtfc_key=$DART_API_KEY" + val key = DART_API_KEY + if (key.isBlank()) { + println("⚠️ [DART] API 키가 설정되지 않아 법인코드 업데이트를 건너뜁니다.") + return + } + val url = "https://opendart.fss.or.kr/api/corpCode.xml?crtfc_key=$key" val response: HttpResponse = client.get(url) val zipBytes = response.readBytes() -// val zipFile = File("dart_corp_codes.zip") -// zipFile.writeBytes(zipBytes) -// println("💾 [디버그] 원본 ZIP 저장 완료: ${zipFile.absolutePath} (${zipBytes.size} bytes)") ZipInputStream(ByteArrayInputStream(zipBytes)).use { zis -> var entry = zis.nextEntry while (entry != null) { if (entry.name == "CORPCODE.xml") { -// saveXmlDebugFile(zipBytes) - parseXml(zis.readAllBytes()) + parseXmlStream(zis) break } entry = zis.nextEntry } } - println("✅ [DART] 매핑 완료: ${corpCodeMap.size}개의 상장사 로드됨") + println("✅ [DART] StAX 스트리밍 매핑 완료: ${corpCodeMap.size}개의 상장사 로드됨") } catch (e: Exception) { println("❌ [DART] 법인코드 업데이트 실패: ${e.message}") } } - private fun parseXml(xmlBytes: ByteArray) { - val factory = DocumentBuilderFactory.newInstance() - val builder = factory.newDocumentBuilder() - val doc = builder.parse(ByteArrayInputStream(xmlBytes)) - val nodeList = doc.getElementsByTagName("list") + private fun parseXmlStream(inputStream: java.io.InputStream) { + val factory = XMLInputFactory.newInstance() + factory.setProperty(XMLInputFactory.SUPPORT_DTD, false) + factory.setProperty("javax.xml.stream.isSupportingExternalEntities", false) - for (i in 0 until nodeList.length) { - val element = nodeList.item(i) as org.w3c.dom.Element - val stockCode = element.getElementsByTagName("stock_code").item(0)?.textContent?.trim() ?: "" - val corpCode = element.getElementsByTagName("corp_code").item(0)?.textContent ?: "" - val corpName = element.getElementsByTagName("corp_name").item(0)?.textContent ?: "" -// println("[$corpName]stockCode: $stockCode , corpCode: $corpCode") - // 종목코드(stock_code)가 있는 상장사만 매핑에 추가 - if (stockCode.isNotEmpty()) { - corpCodeMap[stockCode] = CorpInfo(corpCode, corpName, stockCode) -// AutoTradingManager.addToReanalysis(RankingStock(mksc_shrn_iscd = stockCode, hts_kor_isnm = corpName)) + val reader = factory.createXMLStreamReader(inputStream) + var currentTag = "" + var corpCode = "" + var corpName = "" + var stockCode = "" + + while (reader.hasNext()) { + when (reader.next()) { + XMLStreamConstants.START_ELEMENT -> { + currentTag = reader.localName + } + XMLStreamConstants.CHARACTERS -> { + val text = reader.text.trim() + if (text.isNotEmpty()) { + when (currentTag) { + "corp_code" -> corpCode = text + "corp_name" -> corpName = text + "stock_code" -> stockCode = text + } + } + } + XMLStreamConstants.END_ELEMENT -> { + if (reader.localName == "list") { + if (stockCode.isNotEmpty()) { + corpCodeMap[stockCode] = CorpInfo(corpCode, corpName, stockCode) + } + corpCode = "" + corpName = "" + stockCode = "" + } + currentTag = "" + } } } } diff --git a/src/main/kotlin/network/KisTradeService.kt b/src/main/kotlin/network/KisTradeService.kt index 0ab5450..878a329 100644 --- a/src/main/kotlin/network/KisTradeService.kt +++ b/src/main/kotlin/network/KisTradeService.kt @@ -1,5 +1,6 @@ package network +import Defines.DETAILLOG import io.ktor.client.* import io.ktor.client.call.* import io.ktor.client.engine.cio.CIO @@ -43,10 +44,9 @@ object KisTradeService { encodeDefaults = true // 기본값이 포함된 요청 바디를 정확히 전송하기 위해 필요 }) } - // [수정] 모든 로그(Headers + Body)를 찍도록 설정 install(Logging) { logger = Logger.DEFAULT - level = LogLevel.ALL + level = if (DETAILLOG) LogLevel.HEADERS else LogLevel.NONE } } diff --git a/src/main/kotlin/network/RagService.kt b/src/main/kotlin/network/RagService.kt index ef506cd..4aa8be9 100644 --- a/src/main/kotlin/network/RagService.kt +++ b/src/main/kotlin/network/RagService.kt @@ -1,34 +1,23 @@ -package network// src/main/kotlin/network/RagService.kt +package network // src/main/kotlin/network/RagService.kt import Defines.EMBEDDING_PORT -import Defines.LLM_PORT import TradingLogStore import analyzer.AdvancedTradeAssistant import analyzer.FinancialAnalyzer import analyzer.FinancialMapper import analyzer.FinancialStatement import analyzer.InvestmentScores -import analyzer.ScalpingSignalModel import analyzer.TechnicalAnalyzer import dev.langchain4j.community.rag.content.retriever.lucene.LuceneEmbeddingStore import dev.langchain4j.data.document.Metadata import dev.langchain4j.data.segment.TextSegment -import dev.langchain4j.exception.InternalServerException import dev.langchain4j.model.openai.OpenAiChatModel import dev.langchain4j.model.openai.OpenAiEmbeddingModel -import dev.langchain4j.service.AiServices -import dev.langchain4j.service.SystemMessage import dev.langchain4j.store.embedding.EmbeddingSearchRequest import dev.langchain4j.store.embedding.EmbeddingSearchResult import dev.langchain4j.store.embedding.filter.MetadataFilterBuilder -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.async import kotlinx.coroutines.coroutineScope -import kotlinx.coroutines.delay -import kotlinx.coroutines.withContext -import kotlinx.serialization.Serializable import kotlinx.serialization.json.Json -import kotlinx.serialization.json.add import kotlinx.serialization.json.addJsonObject import kotlinx.serialization.json.buildJsonObject import kotlinx.serialization.json.double @@ -40,16 +29,15 @@ import kotlinx.serialization.json.putJsonArray import kotlinx.serialization.json.putJsonObject import model.ConfigIndex import model.KisSession -import model.RankingStock import model.TradingDecision import okhttp3.MediaType.Companion.toMediaType import okhttp3.OkHttpClient import okhttp3.Request import okhttp3.RequestBody.Companion.toRequestBody import org.apache.lucene.store.MMapDirectory -import org.slf4j.MDC.put import service.AutoTradingManager import service.InvestmentGrade +import service.LlamaServerManager import service.TradingDecisionCallback import service.UrlCacheManager import java.nio.file.Paths @@ -61,15 +49,6 @@ import java.util.Locale import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.TimeUnit -//interface TradingAnalyst { -// @SystemMessage(""" -// You are a Senior Stock Analyst. -// Analyze the data and provide a decision in JSON format. -// You must respond ONLY with a valid JSON object. -// """) -// fun analyzeStock(@dev.langchain4j.service.UserMessage prompt: String): TradingDecision -//} - object RagService { val isSafetyBeltStockCodes = ConcurrentHashMap.newKeySet() @@ -79,51 +58,42 @@ object RagService { println("🧹 [System] 일일 재무 미달 캐시 초기화 완료") } - // 임베딩 모델 (8081) 및 채팅 모델 (8080) 설정 - private val embeddingModel = OpenAiEmbeddingModel.builder() - .baseUrl("http://127.0.0.1:${EMBEDDING_PORT}/v1") - .apiKey("unused") - .build() + // 임베딩 모델은 포트 할당 완료 후 지연 초기화되도록 by lazy 적용 + private val embeddingModel by lazy { + OpenAiEmbeddingModel.builder() + .baseUrl("http://127.0.0.1:${EMBEDDING_PORT}/v1") + .apiKey("unused") + .build() + } - private val chatModel = OpenAiChatModel.builder() - .baseUrl("http://127.0.0.1:${LLM_PORT}/v1") - .apiKey("unused") - .temperature(0.0) // [중요] 0.0으로 설정하여 결정론적 응답 유도 - .timeout(Duration.ofSeconds(60)) -// .frequencyPenalty(1.1) - .maxTokens(400) // 👈 루프 방지를 위해 반드시 짧게 제한! - // 1.x 버전에서는 responseFormat이 아래처럼 바뀔 수 있으니 체크하세요 - .responseFormat("json_object") - .build() - -// private val analyst = AiServices.builder(TradingAnalyst::class.java) -// .chatModel(chatModel) -// .build() + // 채팅 모델은 LlamaServerManager의 활성 포트(Ollama 11434 또는 기존 LLM_PORT)를 지연 바인딩 + private val chatModel by lazy { + OpenAiChatModel.builder() + .baseUrl("http://127.0.0.1:${LlamaServerManager.activeLlmPort}/v1") + .apiKey("unused") + .temperature(0.0) + .timeout(Duration.ofSeconds(60)) + .maxTokens(400) + .responseFormat("json_object") + .build() + } private val embeddingStore: LuceneEmbeddingStore by lazy { val path = Paths.get("db/lucene_idx") - // FSDirectory.open(path)도 가능하지만, 64bit 시스템(Mac)에선 MMapDirectory가 가장 빠릅니다. val directory = MMapDirectory(path) - // 제공해주신 소스의 Builder 사용 LuceneEmbeddingStore.builder() .directory(directory) .build() - } - fun active() { -// println("[Cache] Active") if (UrlCacheManager.isInitialized()) return -// println("[Cache] initialize") UrlCacheManager.initialize(embeddingStore, embeddingModel) } - - /** - * 텍스트를 임베딩하여 H2 DB에 저장합니다. + * 텍스트를 임베딩하여 루씬 DB에 저장합니다. */ fun ingestWithChunking( text: String, @@ -134,7 +104,7 @@ object RagService { corpName: String, stockCode: String ) { - val MAX_CHUNK_SIZE = 500 // 안전하게 500자 내외로 설정 + val MAX_CHUNK_SIZE = 500 // 1. 문단 단위로 먼저 분리 val paragraphs = text.split(Regex("\n\n+")) @@ -142,14 +112,12 @@ object RagService { var currentChunk = StringBuilder() for (para in paragraphs) { - // 현재 청크에 문단을 더했을 때 제한을 넘으면 지금까지의 내용을 확정 if (currentChunk.length + para.length > MAX_CHUNK_SIZE && currentChunk.isNotEmpty()) { chunks.add(currentChunk.toString().trim()) currentChunk = StringBuilder() } currentChunk.append(para).append("\n\n") - // 문단 하나 자체가 너무 긴 경우 글자 수로 강제 분할 if (currentChunk.length > MAX_CHUNK_SIZE) { val longPara = currentChunk.toString() longPara.chunked(MAX_CHUNK_SIZE).forEach { chunks.add(it.trim()) } @@ -161,27 +129,25 @@ object RagService { // 2. 쪼개진 각 청크를 루씬에 개별 임베딩하여 저장 chunks.forEachIndexed { index, chunk -> - if (chunk.length > 10) { // 너무 짧은 노이즈 제외 + if (chunk.length > 10) { val metadata = Metadata() metadata.put("link", newsLink) metadata.put("date", pubDate) - metadata.put("chunk_idx", index) // 순서 정보 유지 - metadata.put("stcokName",stcokName) - metadata.put("corpCode",corpCode) - metadata.put("corpName",corpName) - metadata.put("stockCode",stockCode) + metadata.put("chunk_idx", index) + metadata.put("stcokName", stcokName) + metadata.put("corpCode", corpCode) + metadata.put("corpName", corpName) + metadata.put("stockCode", stockCode) val segment = TextSegment.from(chunk, metadata) val embedding = embeddingModel.embed(segment).content() embeddingStore.add(embedding, segment) } } -// println("🔎 [Lucene] ${chunks.size}개의 청크로 인덱싱 완료") } object JsonSanitizer { fun formatJson(raw: String): String { - // 실제 응답 로그 출력 (디버깅용) println("📥 [AI Raw Response]:\n$raw") val regex = Regex("""\{.*\}""", RegexOption.DOT_MATCHES_ALL) @@ -189,7 +155,7 @@ object RagService { if (match == null) { println("⚠️ [JsonSanitizer] JSON 형식을 찾을 수 없습니다.") - return "{}" // 빈 객체라도 반환하여 EOF 방지 + return "{}" } return match.trim() @@ -203,21 +169,17 @@ object RagService { private fun isRecentNews(dateStr: String?, maxDays: Long = 3): Boolean { if (dateStr.isNullOrBlank()) return false return try { - // 네이버 뉴스 OpenAPI 기본 포맷: "Mon, 06 Apr 2026 12:00:00 +0900" val formatter = DateTimeFormatter.ofPattern("EEE, dd MMM yyyy HH:mm:ss Z", Locale.ENGLISH) val pubDate = ZonedDateTime.parse(dateStr, formatter) val now = ZonedDateTime.now() - - // 뉴스가 미래로 표기된 경우도 대비하여 절대값 처리 Math.abs(ChronoUnit.DAYS.between(pubDate, now)) <= maxDays } catch (e: Exception) { - // 다른 날짜 포맷(예: "yyyy.MM.dd")으로 들어오는 경우를 위한 Fallback try { val fallbackFormatter = DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm", Locale.ENGLISH) val pubDate = ZonedDateTime.parse("$dateStr 00:00 +0900", fallbackFormatter) Math.abs(ChronoUnit.DAYS.between(pubDate, ZonedDateTime.now())) <= maxDays } catch (e2: Exception) { - false // 날짜 파싱 실패 시 보수적으로 '오래된 뉴스'로 취급하여 스크래핑 유도 + false } } } @@ -228,16 +190,21 @@ object RagService { val formatter = DateTimeFormatter.ofPattern("EEE, dd MMM yyyy HH:mm:ss Z", Locale.ENGLISH) val pubDate = ZonedDateTime.parse(dateStr, formatter) val now = ZonedDateTime.now() - - // 현재 시간과 뉴스 발행 시간의 차이를 시간 단위로 계산 val hoursDiff = Math.abs(ChronoUnit.HOURS.between(pubDate, now)) - hoursDiff < maxHours // 1시간 미만이면 true + hoursDiff < maxHours } catch (e: Exception) { false } } - suspend fun processStock(currentPrice: Double, technicalAnalyzer: TechnicalAnalyzer, stockName: String, stockCode: String, isWatering : Boolean, result: TradingDecisionCallback) { + suspend fun processStock( + currentPrice: Double, + technicalAnalyzer: TechnicalAnalyzer, + stockName: String, + stockCode: String, + isWatering: Boolean, + result: TradingDecisionCallback + ) { val totalStartTime = System.currentTimeMillis() coroutineScope { @@ -250,20 +217,18 @@ object RagService { } if (isSafetyBeltStockCodes.contains(stockCode)) { - // 로그를 남기고 싶다면 주석 해제, 아니면 조용히 패스 println("재무 안정성 부족 (캐시)") result(tradingDecision.apply { decision = "HOLD"; reason = "재무 안정성 부족 (캐시)" }, false) return@coroutineScope } - // [1단계] 재무 분석 및 필터링 (가장 빠름) + // [1단계] 재무 분석 및 필터링 val finStartTime = System.currentTimeMillis() val financialData = NewsService.fetchFinancialGrowth(DartCodeManager.getCorpCode(stockCode)?.cCode) val financialStmt = FinancialMapper.mapRawTextToStatement(financialData) val finDuration = System.currentTimeMillis() - finStartTime println("financialStmt ${FinancialAnalyzer.toString(financialStmt)} isSafetyBeltMet ${FinancialAnalyzer.isSafetyBeltMet(financialStmt)}") - // [2단계] 기술적 지표 및 과열 체크 val techStartTime = System.currentTimeMillis() val financialScore = FinancialAnalyzer.calculateScore(financialStmt) @@ -279,47 +244,44 @@ object RagService { return@coroutineScope } val techScore = tradingDecision.signalModel?.compositeScore ?: 0 -// 🌟 신규 매수는 40점 컷오프, 물타기는 20점(또는 제한 없음)으로 하향 val minTechCutoff = if (tradingDecision.isWatering) 15 else 40 if (techScore < minTechCutoff) { logTime(stockName, "기술 점수 미달 조기 종료 ${tradingDecision.signalModel?.compositeScore} , ${tradingDecision.signalModel?.successProbPct} ", techDuration, System.currentTimeMillis() - totalStartTime) if (FinancialAnalyzer.isBuyConsiderationMet(financialStmt) && financialScore > 70) { TradingLogStore.addAnalyzer(stockName, stockCode, "매수 타점 미도달 (재무 우량주로 감시 지속)", true) result(tradingDecision.apply { - decision = "RETRY" // 콜백에서 "BUY"가 아니므로 HOLD와 동일하게 취급됨 + decision = "RETRY" reason = "매수 타점 미도달 (재무 우량주로 감시 지속)" - confidence = 65.0 // AutoTradingManager의 재분석 기준(60.0)을 넘기기 위해 부여 - }, true) // isSuccess를 true로 주어야 콜백이 무시하지 않음 + confidence = 65.0 + }, true) } else { result(tradingDecision.apply { decision = "HOLD"; reason = "매수 타점 미도달" }, false) } return@coroutineScope } - // [3단계] 뉴스 RAG 및 AI 분석 (가장 오래 걸림) + // [3단계] 뉴스 RAG 및 AI 분석 val ragStartTime = System.currentTimeMillis() - // 1시간 이내 뉴스 존재 여부 확인 후 동적 스크래핑 checkAndFetchRecentNews(stockName, stockCode) val question = "$stockName 실적 및 향후 전망" val questionEmbedding = embeddingModel.embed(question).content() - var finalSearchResult : EmbeddingSearchResult? = null + var finalSearchResult: EmbeddingSearchResult? = null try { finalSearchResult = embeddingStore.search( EmbeddingSearchRequest.builder() .queryEmbedding(questionEmbedding) .filter(MetadataFilterBuilder.metadataKey("stockCode").isEqualTo(stockCode)) - .maxResults(10) // 최신 뉴스 3개 적정 + .maxResults(10) .minScore(0.2) .build() ) - } catch (e: Exception) {} + } catch (e: Exception) { + } - - // 3. 검색된 내용을 하나의 문자열로 합쳐서 전달 - tradingDecision.newsContext = finalSearchResult?.matches()?.distinct() // 중복 제거 - ?.take(4) // 10개에서 4개로 축소 - ?.joinToString("\n\n") { + tradingDecision.newsContext = finalSearchResult?.matches()?.distinct() + ?.take(4) + ?.joinToString("\n\n") { it.embedded().text() } @@ -344,10 +306,9 @@ object RagService { val question = "$stockName 실적 전망 및 최근 이슈" val questionEmbedding = embeddingModel.embed(question).content() - // 1. 벡터 DB에서 해당 종목의 뉴스 검색 - var searchResult : EmbeddingSearchResult? = null + var searchResult: EmbeddingSearchResult? = null try { - searchResult = embeddingStore.search( + searchResult = embeddingStore.search( EmbeddingSearchRequest.builder() .queryEmbedding(questionEmbedding) .filter(MetadataFilterBuilder.metadataKey("stockCode").isEqualTo(stockCode)) @@ -356,22 +317,18 @@ object RagService { .build() ) } catch (e: Exception) { - } - // 2. 검색된 뉴스 중 1시간 이내(Very Recent) 데이터가 있는지 확인 val hasHotNews = searchResult?.matches()?.any { match -> val pubDate = match.embedded().metadata().getString("date") isVeryRecentNews(pubDate, maxHours = 1) } ?: false - // 3. 최신 뉴스가 없다면 네이버 API 및 Playwright 스크래핑 가동 if (!hasHotNews) { println("🌐 [$stockName] 최근 1시간 내 분석된 뉴스가 없습니다. 실시간 스크래핑을 시작합니다.") val corpInfo = DartCodeManager.getCorpCode(stockCode) corpInfo?.let { try { - // NewsService에서 오늘자 뉴스를 가져와 인덱싱 수행 NewsService.fetchAndIngestNews(it) } catch (e: Exception) { println("❌ [$stockName] 뉴스 업데이트 실패: ${e.message}") @@ -382,42 +339,32 @@ object RagService { } } - // 시간 기록용 헬퍼 함수 private fun logTime(name: String, status: String, stepMs: Long, totalMs: Long) { println("⏱️ [$name] $status - 단계: ${stepMs}ms / 누적: ${totalMs}ms") } fun isUrlAlreadyIndexed(url: String): Boolean { - // 1. 메타데이터의 'link' 필드가 해당 URL과 일치하는지 필터 구성 val filter = MetadataFilterBuilder.metadataKey("link").isEqualTo(url) - - // 2. 검색 요청 생성 (벡터 유사도와 상관없이 필터 조건에 맞는 것 1개만 찾음) - // 주의: 인터페이스에 따라 더미 벡터(0,0,...)가 필요할 수 있습니다. val searchRequest = EmbeddingSearchRequest.builder() .filter(filter) .maxResults(1) .build() val result = embeddingStore.search(searchRequest) - - // 결과가 비어있지 않다면 이미 저장된 URL입니다. return result.matches().isNotEmpty() } - private fun LLM_API_URL() = "http://127.0.0.1:$LLM_PORT/v1/chat/completions" + // Ollama 활성 여부에 따라 동적으로 11434 또는 LLM_PORT 반환 + private fun LLM_API_URL() = "http://127.0.0.1:${LlamaServerManager.activeLlmPort}/v1/chat/completions" private suspend fun callLlamaWithSchema(prompt: String): String { val jsonMediaType = "application/json; charset=utf-8".toMediaType() - // 문자열 치환 대신 안전한 JSON 객체 빌더 사용 val requestBodyJson = buildJsonObject { - put("model", "local-model") - put("temperature", 0.1) // 💡 루프 탈출을 위해 더 과감하게 설정 - put("top_p", 0.85) // 💡 추가 - put("top_k", 40) // 💡 추가 (서버에서 지원할 경우) -// put("frequency_penalty", 0.7) // 💡 반복 단어 억제 강화 -// put("presence_penalty", 0.5) - + put("model", "qwen3:14b") + put("temperature", 0.1) + put("top_p", 0.85) + put("top_k", 40) put("max_tokens", 200) putJsonArray("messages") { addJsonObject { @@ -429,13 +376,11 @@ object RagService { put("content", prompt) } } - - // 💡 복잡한 json_schema를 지우고, 단순히 JSON 형식으로만 내보내라고 지시합니다. putJsonObject("response_format") { put("type", "json_object") } }.toString() -// println("requestBodyJson =>> $requestBodyJson") + val request = Request.Builder() .url(LLM_API_URL()) .post(requestBodyJson.toRequestBody(jsonMediaType)) @@ -465,54 +410,42 @@ object RagService { financialStmt: FinancialStatement, tempDecision: TradingDecision ): TradingDecision? { - val totalStartTime = System.currentTimeMillis() // 전체 시작 시간 + val totalStartTime = System.currentTimeMillis() - // 1-1. 재무 점수 산출 시간 측정 val finStartTime = System.currentTimeMillis() val finScore100 = FinancialAnalyzer.calculateScore(financialStmt).toDouble() val finDuration = System.currentTimeMillis() - finStartTime - // 1-2. 기술 분석 및 리포트 생성 시간 측정 val techStartTime = System.currentTimeMillis() val techScore100 = tempDecision.signalModel?.compositeScore?.toDouble() ?: 0.0 val isOverheated = tempDecision.analyzer?.isOverheatedStock() ?: false tempDecision.techSummary = tempDecision.analyzer?.generateComprehensiveReport(finScore100.toInt()) val techDuration = System.currentTimeMillis() - techStartTime - // 1-3. 뉴스 AI 분석 시간 측정 (가장 병목이 예상되는 구간) val newsStartTime = System.currentTimeMillis() val (newsScore100, newsReason) = tempDecision.newsContext?.let { - getAiNewsScore(stockName,it, tempDecision.techSummary ?: "") + getAiNewsScore(stockName, it, tempDecision.techSummary ?: "") } ?: (50.0 to "참조 뉴스 없음") val newsDuration = System.currentTimeMillis() - newsStartTime - // 1-4. 시스템 및 가중치 합성 시간 측정 val synthStartTime = System.currentTimeMillis() val sysScore100 = calculateSystemPoint(scores) * 4.0 val hasNews = tempDecision.newsContext != null && tempDecision.newsContext!!.isNotBlank() var finalConfidence = if (hasNews) { - // 뉴스가 있을 때: 원래 로직 (finScore100 * 0.25) + (techScore100 * 0.25) + (newsScore100 * 0.30) + (sysScore100 * 0.20) } else { - // 뉴스가 없을 때: 기술 45%, 재무 35%, 시스템 20%로 배분 (뉴스 영향력 제거) (finScore100 * 0.35) + (techScore100 * 0.45) + (sysScore100 * 0.20) } if (tempDecision.isWatering) { - // 물타기 대상이 여기까지 왔다는 건 '볼린저 하단 터치'나 '초과매도(RSI<35)' 등 바닥 확인이 끝났다는 뜻임. - // 깎인 기술 점수를 보완하기 위해 강한 턴어라운드 기대 가점을 부여 finalConfidence += 20.0 - - // 물타기 전용 등급 강제 상향 (잡주가 아니라는 전제 하에) if (finalConfidence >= KisSession.config.getValues(ConfigIndex.MIN_PURCHASE_SCORE_INDEX) * 0.8) { - // 물타기 전용 등급(예: 신규 매수 로직에 안 잡히게 LEVEL_3 정도로 고정) tempDecision.investmentGrade = InvestmentGrade.LEVEL_3_CAUTIOUS_RECOMMEND } } - // 보너스 및 패널티 로직 if (finScore100 >= 80.0 && techScore100 >= 70.0) finalConfidence += 8.0 if (techScore100 >= 90.0 && finScore100 >= 50.0) finalConfidence += 5.0 if (isOverheated) finalConfidence *= 0.85 @@ -523,7 +456,6 @@ object RagService { tempDecision.midTermScore = scores.midTerm.toDouble() tempDecision.longTermScore = scores.longTerm.toDouble() - // 5. 최종 결정 및 사유 정리 val minScore = KisSession.config.getValues(ConfigIndex.MIN_PURCHASE_SCORE_INDEX) var finalDecision = "HOLD" var finalReason = "" @@ -544,15 +476,13 @@ object RagService { if (!advice.isConfirmed) { grade = InvestmentGrade.LEVEL_0_SPECULATIVE assistantReason = " 🚫 [어시스턴트 차단] ${advice.reason}" - } else if (advice.reason.isNotEmpty()) { // 💡 조건 변경 + } else if (advice.reason.isNotEmpty()) { assistantReason = " ➕ [확인됨: ${advice.reason}]" } } val synthDuration = System.currentTimeMillis() - synthStartTime - - when { newsScore100 < 30.0 -> { finalDecision = "HOLD" @@ -578,7 +508,6 @@ object RagService { val totalDuration = System.currentTimeMillis() - totalStartTime - // 성능 분석 로그 출력 (CSV 형태로 출력하여 나중에 엑셀 분석 가능) println("⏱️ [$stockName] 처리 성능 리포트: 전체 ${totalDuration}ms | 재무 ${finDuration}ms | 기술 ${techDuration}ms | 뉴스AI ${newsDuration}ms | 합성 ${synthDuration}ms") return TradingDecision().apply { @@ -609,8 +538,7 @@ object RagService { } } - - private suspend fun getAiNewsScore(stockName:String , news: String,techSummary : String): Pair { + private suspend fun getAiNewsScore(stockName: String, news: String, techSummary: String): Pair { val prompt = """ # Role: Expert Quantitative & Sentiment Analyst # Target Stock: [$stockName] @@ -652,18 +580,15 @@ object RagService { return try { val raw = callLlamaWithSchema(prompt) println("getAiNewsScore $raw") - // 💡 [핵심 해결책] 마크다운 블록 및 앞뒤 쓸데없는 텍스트 완벽 차단 val startIndex = raw.indexOf("{") val endIndex = raw.lastIndexOf("}") - // '{' 부터 '}' 까지만 정확하게 잘라냄 val sanitizedRaw = if (startIndex != -1 && endIndex != -1) { raw.substring(startIndex, endIndex + 1) } else { - raw // 중괄호를 못 찾았을 경우 대비 (기본 fallback) + raw } - // 정제된 문자열로 JSON 파싱 val json = Json { ignoreUnknownKeys = true }.parseToJsonElement(sanitizedRaw).jsonObject val score = json["score"]?.jsonPrimitive?.double ?: 50.0 @@ -675,15 +600,10 @@ object RagService { } } - - // 재무 점수 계산 (Max 40) private fun calculateFinancialPoint(fs: FinancialStatement): Double { var p = 0.0 - // 영업이익 흑자면 25점, 적자여도 성장 중이면 10점 p += if (fs.isOperatingProfitPositive) 25.0 else (if (fs.operatingProfitGrowth > 30) 10.0 else 0.0) - // ROE 10% 기준 비례 배분 (Max 10) p += (fs.roe / 15.0 * 10.0).coerceIn(0.0, 10.0) - // 부채비율 100% 이하면 5점 만점 p += if (fs.debtRatio <= 100.0) 5.0 else (150.0 - fs.debtRatio).coerceAtLeast(0.0) / 10.0 return p } @@ -691,10 +611,7 @@ object RagService { private fun calculateSystemPoint(s: InvestmentScores): Double { val midLongAvg = (s.midTerm + s.longTerm) / 2.0 val base = (midLongAvg / 100.0 * 15.0) + (s.ultraShort / 100.0 * 10.0) - // 정배열 보너스: 초단기 > 단기 > 중기 점수 순서일 때 가점 val alignmentBonus = if (s.ultraShort > s.shortTerm && s.shortTerm > s.midTerm) 3.0 else 0.0 return (base + alignmentBonus).coerceIn(0.0, 25.0) } -} - - +} \ No newline at end of file diff --git a/src/main/kotlin/service/AutoTradingManager.kt b/src/main/kotlin/service/AutoTradingManager.kt index 51cbf60..77a11fa 100644 --- a/src/main/kotlin/service/AutoTradingManager.kt +++ b/src/main/kotlin/service/AutoTradingManager.kt @@ -73,11 +73,11 @@ object AutoTradingManager { var STUCK_THRESHOLD = KisSession.tradeConfig.STUCK_THRESHOLD var ONE_STOCK_ALYSIS_TIME = KisSession.tradeConfig.ONE_STOCK_ALYSIS_TIME fun isRunning(): Boolean = discoveryJob?.isActive == true - private var remainingCandidates = mutableListOf() + private var remainingCandidates: MutableList = Collections.synchronizedList(mutableListOf()) // private val processedCodes = mutableSetOf() // 중복 처리 방지용 (선택 사항) - private val reanalysisList = mutableListOf() - private val retryCountMap = mutableMapOf() + private val reanalysisList: MutableList = Collections.synchronizedList(mutableListOf()) + private val retryCountMap = ConcurrentHashMap() var shouldShowFullWindow by mutableStateOf(false) var llmAnalyser by mutableStateOf(false) @@ -1149,7 +1149,7 @@ object AutoTradingManager { } } - var loadedTops = mutableListOf>() + var loadedTops: MutableList> = Collections.synchronizedList(mutableListOf()) var defaultStockCount = 30 @@ -1403,7 +1403,7 @@ object AutoTradingManager { } // private var lastForceCheckMinute = -1 // 마지막으로 강제 체크를 수행한 '분'을 저장 - private val executionCountMap = mutableMapOf() + private val executionCountMap = ConcurrentHashMap() suspend fun sellSchedule() { if (KisSession.config.take_profit == false) return val now = LocalTime.now() diff --git a/src/main/kotlin/service/DynamicNewsScraper.kt b/src/main/kotlin/service/DynamicNewsScraper.kt index a61892b..0330cdc 100644 --- a/src/main/kotlin/service/DynamicNewsScraper.kt +++ b/src/main/kotlin/service/DynamicNewsScraper.kt @@ -17,6 +17,7 @@ import network.CorpInfo import network.RagService import util.HardwareDetector import java.net.URL +import java.util.concurrent.ConcurrentHashMap import kotlin.random.Random object BrowserManager { @@ -194,7 +195,7 @@ object DynamicNewsScraper { // } // } - var failCountMap = mutableMapOf() + val failCountMap = ConcurrentHashMap() suspend fun fetchFullContent(url: String): String { val domain = try { URL(url).host } catch (e: Exception) { return "" } if ((failCountMap[domain] ?: 0) > 2) return "" diff --git a/src/main/kotlin/service/LlamaServerManager.kt b/src/main/kotlin/service/LlamaServerManager.kt index b4b54a8..2d2043e 100644 --- a/src/main/kotlin/service/LlamaServerManager.kt +++ b/src/main/kotlin/service/LlamaServerManager.kt @@ -14,48 +14,80 @@ import util.NetworkPortDiagnostic import java.io.BufferedReader import java.io.File import java.io.InputStreamReader +import java.net.HttpURLConnection +import java.net.URL import java.util.concurrent.ConcurrentHashMap object LlamaServerManager { // 포트별로 프로세스를 관리합니다. private val processes = ConcurrentHashMap() private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob()) - init { - killZombieProcesses() + @Volatile + var isOllamaActive: Boolean = false + private set + + val activeLlmPort: Int + get() = if (isOllamaActive) 11434 else LLM_PORT + + init { Runtime.getRuntime().addShutdownHook(Thread { stopAll() }) } - // OS 시스템 명령어를 이용해 찌꺼기 프로세스를 이름으로 찾아 강제 종료하는 함수 - private fun killZombieProcesses() { + // 로컬 Ollama(11434) 서버가 응답하는지 1초 내로 확인 + fun checkOllamaRunning(ollamaPort: Int = 11434): Boolean { + return try { + val url = URL("http://127.0.0.1:$ollamaPort/api/tags") + val conn = (url.openConnection() as HttpURLConnection).apply { + requestMethod = "GET" + connectTimeout = 1000 + readTimeout = 1000 + } + val code = conn.responseCode + conn.disconnect() + code == 200 + } catch (e: Exception) { + false + } + } + + // 특정 포트를 점유하고 있는 프로세스만 선별적으로 종료 (다른 사용자의 llama-server 프로세스 보호) + fun killProcessOnPort(port: Int) { try { val os = System.getProperty("os.name").lowercase() if (os.contains("win")) { - // 윈도우: taskkill 명령어로 llama-server.exe 강제 종료 (/F: 강제, /T: 트리거된 자식까지) - ProcessBuilder("cmd", "/c", "taskkill /F /IM llama-server.exe /T") - .redirectErrorStream(true) - .start() - .waitFor() - println("🧹 [System] 이전 llama-server 좀비 프로세스 정리 완료 (Windows)") + val checkProcess = Runtime.getRuntime().exec("cmd /c netstat -ano | findstr :$port") + val output = checkProcess.inputStream.bufferedReader().readText() + val lines = output.lines().filter { it.contains("LISTENING") } + for (line in lines) { + val pid = line.trim().split(Regex("\\s+")).lastOrNull() + if (!pid.isNullOrBlank() && pid != "0") { + ProcessBuilder("taskkill", "/F", "/PID", pid, "/T") + .redirectErrorStream(true).start().waitFor() + println("🧹 [System] 포트 $port 점유 프로세스($pid) 정리 완료 (Windows)") + } + } } else { - // 맥/리눅스: pkill 사용 - ProcessBuilder("pkill", "-f", "llama-server") - .redirectErrorStream(true) - .start() - .waitFor() - println("🧹 [System] 이전 llama-server 좀비 프로세스 정리 완료 (Mac/Linux)") + val checkProcess = ProcessBuilder("lsof", "-ti", ":$port") + .redirectErrorStream(true).start() + val pids = checkProcess.inputStream.bufferedReader().readLines() + checkProcess.waitFor() + for (pid in pids) { + if (pid.isNotBlank()) { + ProcessBuilder("kill", "-9", pid.trim()).start().waitFor() + println("🧹 [System] 포트 $port 점유 프로세스($pid) 정리 완료 (Mac/Linux)") + } + } } } catch (e: Exception) { - // 실행 중인 프로세스가 없어서 에러가 나도 조용히 무시합니다. + // 정리 실패 시 조용히 무시 } } fun checkPortStatus(port: Int): String { return try { - - // netstat 명령어로 해당 포트를 점유 중인 프로세스 확인 val process = Runtime.getRuntime().exec("cmd /c netstat -ano | findstr :$port") val reader = process.inputStream.bufferedReader() val result = reader.readText() @@ -72,6 +104,19 @@ object LlamaServerManager { } fun startServer(binPath: String, modelPath: String, port: Int) { + // 메인 LLM 서버 기동 요청 시 외부 Ollama(11434)가 이미 떠 있다면 공유 모드로 우회 + if (port == LLM_PORT) { + if (checkOllamaRunning(11434)) { + isOllamaActive = true + println("🔗 [System] 로컬 Ollama(11434) 활성 감지 -> 내장 llama-server 대신 Ollama를 공유합니다.") + AutoTradingManager.llmAnalyser = true + return + } else { + isOllamaActive = false + println("ℹ️ [System] Ollama 미실행 상태 -> 내장 llama-server(Port: $port)를 기동합니다.") + } + } + val os = System.getProperty("os.name").lowercase() val arch = System.getProperty("os.arch").lowercase() val isWin = os.contains("win") @@ -80,18 +125,17 @@ object LlamaServerManager { val canUsePort = if (isWin) NetworkPortDiagnostic.testPortAvailability(port) else true if (canUsePort) { if (processes.containsKey(port) || modelPath.isBlank()) return - val cpuCores = Runtime.getRuntime().availableProcessors() // HardwareDetector.getCpuCores()와 동일 + // 포트 충돌 방지를 위해 해당 포트 점유 프로세스 선별 정리 + killProcessOnPort(port) + val cpuCores = Runtime.getRuntime().availableProcessors() val hasGpu = HardwareDetector.hasNvidiaGpu() val ratio = if (isWin) 0.5 else 0.7 - val optimalThreads = if(isWin)(cpuCores * ratio).toInt().coerceIn(4, 12) else (cpuCores * ratio).toInt().coerceIn(4, 16) + val optimalThreads = if (isWin) (cpuCores * ratio).toInt().coerceIn(4, 12) else (cpuCores * ratio).toInt().coerceIn(4, 16) - var optimalGpuLayers = 99 //if ((isWin && hasGpu) || isMacArm) 99 else 4 -// if(HardwareDetector.getCpuName().contains("i7")) { -// optimalGpuLayers = 0 -// } - println("🖥️ OS: $os / Arch: $arch") - println("⚙️ 할당 스레드: $optimalThreads (Core: $cpuCores, Ratio: $ratio)") - println("🚀 GPU 레이어: $optimalGpuLayers (NVIDIA/MacArm: ${if(optimalGpuLayers == 99) "YES" else "NO"})") + var optimalGpuLayers = 99 + println("🖥️ OS: $os / Arch:$arch") + println("⚙️ 할당 스레드: $optimalThreads (Core: $cpuCores, Ratio:$ratio)") + println("🚀 GPU 레이어: $optimalGpuLayers (NVIDIA/MacArm:${if (optimalGpuLayers == 99) "YES" else "NO"})") val command = mutableListOf( binPath, @@ -102,15 +146,13 @@ object LlamaServerManager { "-t", optimalThreads.toString(), "--embedding", "--mlock", // RAM 고정으로 스왑 방지 - "--no-mmap", - - + "--no-mmap" ) if (port != EMBEDDING_PORT) { // 텍스트 생성용 모델에만 적용 command.addAll(listOf( - "-b", "512", // Batch size (토큰 병렬 처리량 제한으로 연산 안정화) + "-b", "512", "--threads-batch", optimalThreads.toString(), - "-fa","on", // Flash Attention 활성화 (메모리 절약 및 긴 컨텍스트 연산 안정성 증가) + "-fa", "on", "--cont-batching" )) } @@ -123,19 +165,13 @@ object LlamaServerManager { try { val pb = ProcessBuilder(command) - // 2. 윈도우 Vulkan 환경 변수 설정 - if (isWin ) { + if (isWin) { val env = pb.environment() - // 특정 GPU 선택 (내장 GPU가 여러 개일 경우) - env["GGML_VULKAN_DEVICE"] = "0" + env["GGML_VULKAN_DEVICE"] = "0" env["GGML_VULKAN_MAX_NODES"] = "1" - // DLL 로드 경로 강제 지정 (bin 폴더 내 dll 참조) val libraryPath = File(binPath).parentFile.absolutePath - - val currentPath = System.getenv("PATH") ?: "" env["PATH"] = "$libraryPath;$currentPath" - println("🔧 [Vulkan] 환경 변수 설정 완료: $libraryPath") } @@ -144,66 +180,59 @@ object LlamaServerManager { val process = pb.start() processes[port] = process - println("✅ AI 서버 시작 시도 (Port: $port, Model: ${File(modelPath).name})") + println("✅ AI 서버 시작 시도 (Port: $port, Model:${File(modelPath).name})") if (isWin) { delay(3000) - val status = checkPortStatus(port) - println(status) // 콘솔 로그 + println(status) TradingLogStore.addAnalyzer("System", "Port:$port", status, status.contains("✅")) } - Thread { - process.errorStream.bufferedReader().use { reader -> - reader.lines().forEach { line -> println("[SERVER ERROR] $line") } - } - }.start() val reader = BufferedReader(InputStreamReader(process.inputStream)) var line: String? while (reader.readLine().also { line = it } != null) { - // 로그 출력 (디버깅용) - if (DETAILLOG) println("[Server $port] $line") + if (DETAILLOG) println("[Server $port]$line") if (line?.contains("server is listening") == true) { println("🚀 AI 서버 준비 완료 (Port: $port)") - if (port == LLM_PORT){ + if (port == LLM_PORT) { AutoTradingManager.llmAnalyser = true } - if (port == EMBEDDING_PORT){ + if (port == EMBEDDING_PORT) { AutoTradingManager.llmNews = true RagService.active() } if (processes.size > 1) { println("[Cache] ${processes.size}") - } } } } catch (e: Exception) { - println("❌ AI 서버 실행 실패 (Port: $port): ${e.message}") + println("❌ AI 서버 실행 실패 (Port: $port):${e.message}") processes.remove(port) } - } } else { println("🚨 포트 $port 가 보안 정책에 의해 막혀있어 서버 기동을 중단합니다.") TradingLogStore.addAnalyzer("System", "Port:$port", "보안 정책에 의한 포트 차단 감지", false) } - - } fun stopAll(): Boolean { - var allStopped = true // 모든 프로세스 종료 여부를 추적하는 플래그 + var allStopped = true processes.forEach { (port, process) -> try { - process.destroy() // 1차: 부드러운 종료 시도 + // 자식 및 자손 프로세스도 함께 종료 + try { + process.toHandle().descendants().forEach { it.destroyForcibly() } + } catch (e: Exception) { + // 무시 + } + process.destroy() - // 2차: 최대 3초 대기 후 종료되지 않으면 강제 종료 if (!process.waitFor(3, java.util.concurrent.TimeUnit.SECONDS)) { - process.destroyForcibly() // 강제 사살 + process.destroyForcibly() - // 강제 종료 후에도 프로세스가 살아있는지 최종 확인 if (process.isAlive) { println("❌ [Server $port] 강제 종료 명령 후에도 프로세스가 살아있습니다.") allStopped = false @@ -220,7 +249,7 @@ object LlamaServerManager { } if (allStopped) { - processes.clear() // 모든 프로세스가 성공적으로 종료되거나 리스트에서 제거될 준비가 된 경우 + processes.clear() } return allStopped diff --git a/todo.md b/todo.md new file mode 100644 index 0000000..ae5dcb5 --- /dev/null +++ b/todo.md @@ -0,0 +1,235 @@ +# AutoTradeAI 시스템 안정성 및 성능 개선 과제 (todo.md) + +본 문서는 **AutoTradeAI** 프로젝트의 코드베이스 분석 결과 발견된 아키텍처, 성능, 동시성, 리소스 관리, 매매 안정성 관련 잠재적 문제점을 정리하고, 우선순위별 구체적인 해결 방안 및 체크리스트를 제공합니다. + +--- + +## 📌 우선순위 요약 (Priority Overview) + +| 구분 | 중요도 | 내용 요약 | 상태 | +| :---: | :---: | :--- | :---: | +| **P0** | **Critical** | 시스템 크래시, 메모리 누수(OOM), 프로세스 충돌, 포트 불일치 등 치명적 결함 | 🚨 조치 필요 | +| **P1** | **High** | API Rate Limit 초과, 재무 데이터 하드코딩, 브라우저 프로세스 누수 등 매매 실패 요인 | ⚠️ 개선 권장 | +| **P2** | **Medium** | DB 동기 블로킹, 설정 저장소 이원화, 불필요한 OS 서브프로세스 호출, 코드 비대화 | 📋 리팩토링 권장 | +| **P3** | **Low** | 구조화된 로깅, 예외 억제 제거, 단위 테스트 및 시뮬레이션 검증 슈트 | 💡 품질 개선 | + +--- + +## 🚨 P0: 치명적 결함 및 안정성 과제 (Critical) + +### 1. `RagService` 임베딩 모델 포트 바인딩 타이밍 결함 수정 +- **위치**: `src/main/kotlin/network/RagService.kt:62` +- **현상**: + ```kotlin + // RagService.kt + private val embeddingModel = OpenAiEmbeddingModel.builder() + .baseUrl("http://127.0.0.1:${EMBEDDING_PORT}/v1") + .apiKey("unused") + .build() + ``` + `embeddingModel`이 싱글톤 객체 로드 시점에 즉시 인스턴스화됨. `Main.kt`에서 `PortFinder`로 `EMBEDDING_PORT`를 동적으로 변경(예: 18082)하기 전에 `RagService`가 참조되면 기본값(8081)으로 바인딩되어 임베딩 API 호출이 영구 실패함. +- **해결 방안**: + `by lazy` 또는 동적 포트 참조 팩토리 메서드로 변경하여 `Main.kt`에서 포트 할당이 완료된 이후에 인스턴스가 생성되도록 보장. +- **체크리스트**: + - [ ] `embeddingModel`을 lazy 초기화 또는 함수 기반으로 전환 + - [ ] 기동 시 LLM/Embedding 포트 일치 여부 헬스체크 추가 + +--- + +### 2. `LlamaServerManager`의 무차별 시스템 프로세스 종료(`pkill`) 방지 +- **위치**: `src/main/kotlin/service/LlamaServerManager.kt:69` +- **현상**: + ```kotlin + ProcessBuilder("pkill", "-f", "llama-server").start().waitFor() + ``` + 앱 실행 시 시스템의 모든 `llama-server` 프로세스를 무차별 강제 종료함. 사용자가 터미널 등에서 별도로 띄운 LLM 서버까지 의도치 않게 죽이는 심각한 부작용 발생. +- **해결 방안**: + - 앱이 직접 실행한 자식 프로세스의 `Process.pid()`를 저장 및 관리. + - 종료 시 해당 PID 및 자식 프로세스 트리만 명시적으로 `destroyProcessForcibly` 처리. +- **체크리스트**: + - [ ] `killZombieProcesses`의 전역 `pkill -f` 제거 + - [ ] PID 기반 프로세스 추적 및 안전한 graceful shutdown 로직 적용 + +--- + +### 3. 대용량 XML(30MB) 파싱 시 힙 메모리 폭증(DOM -> StAX 스트리밍 전환) +- **위치**: `src/main/kotlin/network/DartCodeManager.kt:216` +- **현상**: + DART 전체 기업 고유번호 파일(`CORPCODE.xml`)은 압축 해제 시 약 29MB~30MB에 달함. 현재 `DocumentBuilderFactory` DOM 파서로 전체 문서를 메모리 트리로 로드하여 순간적으로 수백 MB의 힙 메모리를 소모하고 심한 GC 지연 또는 OOM 위험 발생. +- **해결 방안**: + `javax.xml.stream.XMLStreamReader` (StAX) 또는 SAX 파서를 적용하여 메모리에 문서를 적재하지 않고 스트리밍 방식으로 필요한 ``, ``, `` 태그만 즉시 추출. +- **체크리스트**: + - [ ] `parseXml`을 StAX 스트리밍 파서로 리팩토링 + - [ ] 메모리 사용량 프로파일링 및 힙 점유율 최적화 확인 (수백 MB -> 수 MB) + +--- + +### 4. 동시성 코루틴 환경에서 스레드 안전하지 않은 컬렉션 사용 수정 +- **위치**: + - `src/main/kotlin/service/DynamicNewsScraper.kt:197`: `failCountMap = mutableMapOf()` + - `src/main/kotlin/service/AutoTradingManager.kt:76, 79, 80`: `remainingCandidates = mutableListOf()`, `reanalysisList`, `retryCountMap` +- **현상**: + 비동기 코루틴 스레드 풀(`Dispatchers.Default`, `Dispatchers.IO`)에서 일반 `MutableMap`, `MutableList`에 동시 접근 및 수정이 발생하여 `ConcurrentModificationException` 발생 또는 상태 데이터 오염 유발. +- **해결 방안**: + - `ConcurrentHashMap`, `Collections.synchronizedList`, 또는 코루틴 `Mutex`를 통해 동기화 보장. +- **체크리스트**: + - [ ] `DynamicNewsScraper.failCountMap`을 `ConcurrentHashMap`으로 변경 + - [ ] `AutoTradingManager`의 공유 리스트/맵 컬렉션 스레드 세이프화 + +--- + +### 5. `KisTradeService`의 `LogLevel.ALL`로 인한 메모리/성능 부하 및 키 노출 제거 +- **위치**: `src/main/kotlin/network/KisTradeService.kt:49` +- **현상**: + ```kotlin + install(Logging) { + logger = Logger.DEFAULT + level = LogLevel.ALL // 매 요청/응답 헤더와 수천 줄의 캔들 JSON 바디가 문자열로 버퍼링됨 + } + ``` + 수백 종목의 분봉/일봉/주봉 캔들 데이터 수신 시 엄청난 양의 I/O 로그가 생성되어 메모리 버퍼 낭비, 콘솔 출력 지연, 헤더 내 인증 토큰 및 AppKey 노출 발생. +- **해결 방안**: + `Defines.DETAILLOG` 설정에 따라 디버그 모드가 아닐 때는 `LogLevel.NONE` 또는 `LogLevel.INFO`로 설정. +- **체크리스트**: + - [ ] `KisTradeService`의 Ktor 로깅 레벨을 환경 설정 연동으로 수정 + - [ ] 민감 정보(AppKey, SecretKey) 헤더 마스킹 확인 + +--- + +## ⚠️ P1: 매매 신뢰성 및 리소스 누수 방지 (High) + +### 6. 증권사 KIS OpenAPI 호출 레이트 리밋(Rate Limit) 방어 메커니즘 도입 +- **위치**: `src/main/kotlin/service/AutoTradingManager.kt:1540`, `src/main/kotlin/network/KisTradeService.kt` +- **현상**: + 임의의 `delay(40)`, `delay(50)` 슬립에만 의존하여 연속적인 캔들/시세 조회 시 KIS Open API의 초당 호출 제한(초당 2~5회)을 초과하여 `EGW00201` (초당 거래건수 초과) 오류 발생 및 종목 분석 스킵. +- **해결 방안**: + 토큰 버킷(Token Bucket) 기반의 `KisRateLimiter`를 구현하여 모든 KIS REST 요청이 초당 최대 3회 이하로 통제되도록 일원화. +- **체크리스트**: + - [ ] 코루틴 지원 `TokenBucketRateLimiter` 구현 + - [ ] `KisTradeService`의 모든 외부 API 엔드포인트 호출부에 레이트 리미터 적용 + +--- + +### 7. DART 재무제표 API의 사업연도 하드코딩 제거 및 최신 분기/사업보고서 동적 조회 +- **위치**: `src/main/kotlin/network/NewsService.kt:117` +- **현상**: + ```kotlin + val url = "https://opendart.fss.or.kr/api/fnlttSinglAcnt.json?crtfc_key=$apiKey&corp_code=$corpCode&bsns_year=2024&reprt_code=11011" + ``` + 사업연도 2024년 및 사업보고서 코드(11011)가 고정되어 있어, 현재 시점의 최신 재무 실적(분기보고서, 반기보고서)을 반영하지 못하고 과거 재무로 오판할 위험. +- **해결 방안**: + 현재 날짜(`LocalDate.now()`)를 기반으로 당해 연도 및 직전 연도를 계산하고, 최신 공시된 보고서(3분기 11014 -> 반기 11012 -> 1분기 11013 -> 사업보고서 11011)를 우선 탐색하는 fallback 로직 구현. +- **체크리스트**: + - [ ] 연도 및 보고서 코드 동적 계산 로직 추가 + - [ ] 당해 연도 미공시 시 직전 연도 사업보고서 자동 fallback 처리 + +--- + +### 8. 로컬 LLM 추론 시 모델명 하드코딩 제거 및 유연한 모델 매핑 +- **위치**: `src/main/kotlin/network/RagService.kt:362` +- **현상**: + `callLlamaWithSchema`에서 `put("model", "qwen3:14b")`가 하드코딩되어 있음. 사용자가 Ollama를 공유 모드로 사용할 때 해당 모델이 로컬에 없으면 404 Model Not Found 에러가 발생하여 뉴스 AI 분석이 모두 실패함. +- **해결 방안**: + - `TradeConfig` 또는 `AppConfig`에 사용할 모델명을 설정 항목으로 추가. + - Ollama 모드일 경우 `/api/tags` 엔드포인트에서 로컬에 설치된 첫 번째 모델명을 자동 감지하여 채택. +- **체크리스트**: + - [ ] 모델명 동적 주입 구조로 변경 + - [ ] Ollama 가용 모델 자동 탐색 fallback 로직 구현 + +--- + +### 9. Playwright 헤드리스 브라우저 프로세스 수명주기 및 좀비 방지 강화 +- **위치**: `src/main/kotlin/service/DynamicNewsScraper.kt:22` +- **현상**: + 크롤링 도중 예외가 발생하거나 앱이 비정상 종료되었을 때 Chromium 브라우저 서브프로세스가 완전히 정리되지 않고 남아 CPU/메모리를 낭비함. +- **해결 방안**: + - JVM 종료 훅(`Runtime.getRuntime().addShutdownHook`)에 `BrowserManager.closeIfIdle(0)` 및 브라우저 강제 종료 등록. + - 브라우저 Context 생성 시 리소스 블로킹(이미지, CSS, 폰트 다운로드 차단)을 활성화하여 메모리 점유 및 네트워크 낭비 차단. +- **체크리스트**: + - [ ] Playwright 브라우저 종료 훅 등록 + - [ ] `blockUnnecessaryResources` 활성화로 불필요한 미디어 파일 로드 차단 + +--- + +### 10. Exposed DB 트랜잭션의 동기 블로킹 호출 비동기 전환 +- **위치**: `src/main/kotlin/database/DatabaseFactory.kt` +- **현상**: + `DatabaseFactory`의 다수 함수가 `transaction(mainDb) { ... }`를 동기 호출하고 있음. H2 파일 I/O나 락 대기 시 UI 메인 스레드나 디폴트 디스패처가 멈출 위험. +- **해결 방안**: + `newSuspendedTransaction(Dispatchers.IO) { ... }`로 전환하여 코루틴 환경에서 I/O 스레드를 점유하지 않도록 개선. +- **체크리스트**: + - [ ] `DatabaseFactory`의 트랜잭션 함수들을 `suspend` 및 `Dispatchers.IO` 기반으로 리팩토링 + - [ ] UI 스레드에서의 DB 직접 호출 전면 제거 + +--- + +## 📋 P2: 구조 개선 및 성능 최적화 (Medium) + +### 11. 설정 저장소 이원화(H2 DB vs `trade_config.json`) 일원화 +- **현상**: + 기본 계좌/API 설정은 H2 DB `ConfigTable`에 저장되고, 자동매매 루프 세부 파라미터는 `trade_config.json`에 저장되어 설정 수정 시 일관성 유지 및 백업이 번거로움. +- **개선 방안**: + - 모든 설정을 H2 DB 단일 테이블로 마이그레이션하거나, `ConfigManager` 추상화 계층을 두어 단일 진입점에서 읽기/쓰기를 보장. +- **체크리스트**: + - [ ] 설정 데이터 스키마 통합 설계 + - [ ] GUI 설정 화면에서 모든 파라미터를 단일 저장소로 즉시 반영 + +--- + +### 12. 텔레그램 알림 시 OS `curl` 프로세스 포크 제거 -> Ktor 비동기 HTTP 전환 +- **위치**: `src/main/kotlin/network/NewsService.kt:149` +- **현상**: + 알림 발송 시마다 `Thread`를 생성하고 `ProcessBuilder("curl", ...)`를 실행하여 OS 서브프로세스를 매번 포크함. +- **개선 방안**: + 기존 Ktor HTTP Client를 사용하여 비동기 `client.post` 방식으로 발송하도록 리팩토링. +- **체크리스트**: + - [ ] `sendViaSystemCurl` 제거 및 Ktor 비동기 POST로 변경 + +--- + +### 13. `AutoTradingManager.kt` 비대화 해결 (책임 분리) +- **현상**: + `AutoTradingManager.kt`가 1,872라인에 달하며 스케줄링, 후보 발굴, 물타기 큐 계산, KIS 주문 집행, 시간외 매도, 리포팅 등 너무 많은 책임을 한 파일에서 처리함. +- **개선 방안**: + - `OrderExecutor`: 매수/매도 주문 전송, 호가 계산, 미체결 취소 전담 + - `WateringStrategy`: 물타기 대상 우선순위 및 단가 계산 전담 + - `MarketTimeScheduler`: 장 시작/마감 시간 스케줄링 및 상태 전이 전담 +- **체크리스트**: + - [ ] 도메인별 매니저/서비스 클래스 분리 및 단위 테스트 가능한 구조로 리팩토링 + +--- + +### 14. `LlamaServerManager` 스트림 리다이렉트 충돌 정리 +- **위치**: `src/main/kotlin/service/LlamaServerManager.kt:167, 179` +- **현상**: + `pb.redirectErrorStream(true)`로 stdout/stderr가 병합되었는데, 별도 스레드로 `process.errorStream`을 읽으려 시도함. +- **개선 방안**: + 불필요한 별도 errorStream 읽기 스레드를 제거하고 단일 inputStream 루프에서 통합 처리. +- **체크리스트**: + - [ ] 스트림 리다이렉트 중복 스레드 제거 + +--- + +## 💡 P3: 코드 품질, 로깅 및 테스트 (Low) + +### 15. 침묵하는 예외(Swallowed Exceptions) 및 구조화된 로깅 개선 +- **현상**: + 코드 곳곳에 `catch (e: Exception) { println(e.message) }` 형태로 예외가 억제되거나 스택트레이스 없이 무시되는 블록이 다수 존재하여 실거래 오류 원인 파악이 어려움. +- **개선 방안**: + - SLF4J Logger를 도입하여 레벨별(DEBUG, INFO, WARN, ERROR) 구조화된 로깅 적용. + - 주문 실패나 웹소켓 단절 시 상세 사유를 `TradingLogStore` 및 DB 로그에 명확히 기록. +- **체크리스트**: + - [ ] 빈 `catch` 블록 및 무분별한 `println`을 로거 호출로 전환 + - [ ] 실거래 주문 에러 코드별 구체적 가이드 로그 출력 + +--- + +### 16. 시뮬레이션 모드 모킹 및 단위 테스트 커버리지 구축 +- **현상**: + `isSimulation = true`일 때도 실제 증권사 모의서버 통신에 의존하여, 장외 시간이나 네트워크 오프라인 상태에서 기술적 지표 알고리즘(`TechnicalAnalyzer`), 위험 관리(`RiskManager`), 물타기 계산 등을 검증할 단위 테스트가 없음. +- **개선 방안**: + - 과거 일봉/분봉 샘플 캔들 데이터를 기반으로 한 `TechnicalAnalyzerTest` 작성. + - 위험 종목 차단 규칙 검증용 `RiskManagerTest` 작성. +- **체크리스트**: + - [ ] 퀀트 지표 계산 공식 단위 테스트 작성 + - [ ] 위험 필터링 조건 단위 테스트 작성