Kua's Miscellaneous

[리버스 엔지니어링] 앱 감청 (Android 16)

Kua — Mon, 16 Feb 2026 02:51:04 +0900

Windows 11 기준으로 작성되었습니다.

1. 앱 APK 확보

가장 빠르고 좋은건 APK Mirror 와 같은 사이트에서 apk 파일을 직접 다운로드 하는 것이고,

유명하지 않은 앱이다 하면 없을 가능성이 높다.

그 경우 https://github.com/AbdurazaaqMohammed/AntiSplit-M

프로그램을 이용하여 설치된 앱에서도 apk 파일로 추출해낼 수 있다.

2. APK 디컴파일

https://apktool.org/

https://github.com/iBotPeaches/Apktool

Apktool을 이용하여 smali 형식의 저수준 언어로된 패키지가 반환된다.

API 엔드포인트와 간단한 어플리케이션의 구조를 알아보기 위해서는 이 파일을 통쨰로 AI에게 맡기면 잘 해석해준다.

여기서만으로도 해결될 수 있음

3. 앱 네트워크 감청 (비루팅폰 기준)

Charles, Fiddler, Proxyman(macOS Only) 와 같은 소프트웨어를 준비한다.

이 글에선 Charles 5.0.3으로 진행

Root 인증서 설치 진행

HTTPS 까지 감청을 해야 하는데 기본적으로 앱 보안상 공식 CA 인증서가 아닌 루트를 통하면 데이터가 정상적으로 송수신되지 못함으로 리버싱을 할 앱에서 사용하는 도메인만 등록하여 휴대폰 사용에 문제 없도록 한다. (개발용 단말이 따로 있다면 이 절차는 패스)

이 자물쇠를 이용해 SSL 요청도 프록시를 타도록 할지 말지를 결정해준다.

보이는 것 처럼 휴대폰에서 프록시를 타도록 해주고, chls.pro/ssl 로 접속하면 인증서를 다운로드할 수 있다.

WIFI 프록시 설정

chls.pro/ssl 에 접근하여 인증서 다운로드

012

다운받은 인증서를 등록

개발 완료 후 이 인증서는 보안상 삭제해주도록 하자.

apktool로 디컴된 앱 소스코드에서

./res/xml 경로에 network_security_config.xml 파일을 작성한다.

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
  <base-config>
    <trust-anchors>
      <certificates src="system" />
      <certificates src="user" />
    </trust-anchors>
  </base-config>
</network-security-config>

AndroidManifest.xml의 <application ... 부분을 찾아 android:networkSecurityConfig="@xml/network_security_config" 를 추가해준다.

intellij에서 Android 에뮬을 돌려보았거나, Android Studio가 PC에 설치된 적이 있었다면

C:\Users\{Account}\AppData\Local\Android\Sdk 경로에 앱 빌드를 위한 툴과 SDK가 모두 존재할 것이다. 필자는 가장 최신버전으로 빌드 하였다.

PowerShell

$SDK = "$env:LOCALAPPDATA\Android\Sdk"
$BT  = "$SDK\build-tools\36.1.0"

& "$BT\zipalign.exe" -p -f 4 .\apkname-mitm.apk .\apkname-mitm-aligned.apk

& "$BT\apksigner.bat" sign `
  --ks "$env:USERPROFILE\.android\debug.keystore" `
  --ks-key-alias androiddebugkey `
  --ks-pass pass:android `
  --key-pass pass:android `
  --out .\apkname-mitm-signed.apk `
  .\apkname-mitm-aligned.apk

& "$BT\apksigner.bat" verify --verbose --print-certs .\apkname-mitm-signed.apk

빌드 후 설치해주면 모든 준비는 끝.

이제 앱을 구동하여 사용해보면

이렇게 HTTPS도 정상적으로 모든 요청과 응답을 파싱해서 볼 수 있게 된다.

AI 자동매매 시스템 만들기 #6 - 예외처리시간! (LLM 환각, WebSocket 재연결, API 비용 최적화)

Kua — Thu, 12 Feb 2026 15:37:27 +0900

문제 1: LLM이 JSON 대신 마크다운을 뱉어버렸다

AI 분석이 간혹 가다 실패하기 시작했습니다. JSON을 달라고 했는데 마크다운으로 답변하고 있었습니다.

원인 분석

Qwen3 14B 모델은 "thinking 모드"를 지원합니다. 사고 과정을 <think>...</think> 태그 안에 쓰고, 그 다음에 JSON 응답을 줍니다. 그런데 간헐적으로 JSON 대신 마크다운으로 응답하는 경우가 생겼습니다.

해결: 정규표현식 폴백 파서

JSON 파싱 실패 시 마크다운에서 직접 데이터를 추출하는 폴백 로직을 추가했습니다. 정규표현식으로 "추천: BUY", "신뢰도: 75%" 같은 패턴을 찾아서 JSON으로 변환합니다.

JSON 파싱 성공률이 82% → 98%로 올라갔습니다.

문제 2: LLM 환각으로 감시 종목 절반을 매칭해버림

"반도체 업황 호조" 같은 일반적인 뉴스에 감시 종목 30개 중 12개를 매칭했습니다. 명백한 환각(hallucination)입니다.

원인 분석

LLM은 "반도체 업황"이라는 단어만 보고 반도체와 간접적으로라도 연관된 모든 종목을 매칭했습니다. 심지어 금융주까지 포함했죠 (반도체 주가 상승 → 코스피 상승 → 금융주 수혜라는 논리).

해결 방법

1. 프롬프트에 엄격한 규칙 추가: "직접 언급" 또는 "핵심 사업 연관"만 허용

2. 환각 탐지 로직: 감시 종목의 절반 이상 매칭되면 전체를 버림

if (matched.size > watchStocks.size / 2 && matched.size > 3) {
    logger.warn { "LLM 매칭 환각 감지 → 전체 무시" }
    return emptyList()
}

각 사례가 유의미하게 감소했습니다.

문제 3: Tavily URL 크롤링이 사이드바까지 긁어왔다

기사 주제는 "삼성전자 HBM 수주"인데 SK텔레콤, 현대차까지 매칭됐습니다.

원인 분석

Tavily는 URL의 전체 본문을 추출하는데, 뉴스 사이트의 사이드바, 관련 기사, 광고까지 포함됩니다. 전체 텍스트에서 종목명을 찾으니 관련 없는 종목까지 매칭됐습니다.

해결 방법

기사 본문은 대부분 앞쪽에 있습니다. 앞 1500자만 사용하도록 수정:

val allContent = extracts.joinToString(" ") {
    (it.rawContent ?: "").take(1500)  // 본문 앞부분만
}

TAVILY 매칭 정확도가 일부 상승했습니다.

문제 4: Mock 모드 WebSocket 실패 시 장 상태를 모르게 됨

개발 환경에서 Mock WebSocket이 실패하면 실제 장이 열려있어도 거래를 안 합니다.

해결 방법: 시간 기반 Fallback

WebSocket 실패 시 현재 시간으로 장 상태를 추정:

1순위: WebSocket 실시간 상태
2순위: 시간 기반 추정 (평일 09:00-15:30)

개발 환경에서 WebSocket 없이도 거래 테스트가 가능해졌습니다.

문제 5: Brave 검색 크레딧을 허공에 날려버림

Brave Search API는 유료입니다(월 2,000회 무료). 그런데 "코스피 장 마감", "달러 환율" 같은 일반 시황까지 검색하고 있었습니다.

해결 방법: LLM으로 검색 가치 판단

Brave 검색 전에 LLM으로 "검색할 가치가 있는가?"를 먼저 판단:

data class BraveQueryRefinementResult(
    val worthSearching: Boolean,
    val searchQuery: String,
    val reason: String
)

LLM이 worthSearching=false를 반환하면 검색을 스킵합니다.

요약: 실전 운영에서 배운 교훈

LLM은 확률적 모델 → 다양한 출력 포맷 허용하는 견고한 파서 필요
LLM 환각 대비 → 프롬프트 엔지니어링 + 코드 검증 병행
Reactive Streams retry → retryWhen()으로 정교한 제어 + 전역 카운터 관리
웹 크롤링 노이즈 제거 → 앞부분만 사용, 도메인 지식 활용
외부 시스템 의존도 낮추기 → 시간 기반 Fallback 전략
API 비용 절감 → 호출 전 LLM으로 가치 판단

AI 자동매매 시스템 만들기 #5 - RAG로 AI에게 기억력을 주다(pgvector)

Kua — Thu, 12 Feb 2026 15:17:20 +0900

AI가 과거를 기억하지 못한다

초기 시스템의 치명적인 약점이 있었습니다. AI가 실시간으로 들어오는 정보만 보고 판단한다는 거예요.

예를 들어 텔레그램 채널에서 이런 메시지들이 왔다고 가정해봅시다:

월요일 오전: "삼성전자 분석 - 반도체 업황 회복 조짐, 목표가 85,000원"
월요일 오후: "삼성전자 실적 발표 예정, 컨센서스 상회 전망"
화요일 오전: "삼성전자 추가 매수 의견, 기술적 지지선 돌파"
수요일: "삼성전자" (단 3글자만)

AI는 수요일 메시지를 볼 때 이전 3일간의 맥락을 전혀 모릅니다. 단순히 "삼성전자"라는 키워드만 보고 분석하죠. 당연히 정확도가 떨어질 수밖에 없습니다.

RAG 구축

RAG는 간단히 말하면 "관련 있는 과거 정보를 찾아서 AI에게 함께 제공하는 기술"입니다.

이를 위해선 벡터 DB가 필요한데, Qdrant와 Pgvector 중에서 고민 끝에 pgvector로 결정하였습니다.

이유는 SQLite의 확장성 제약에 마이그레이션도 하는 겸 + 벤치마크 또한 pgvector가 우위에 있었는 점 이었습니다.

참고 자료: https://www.tigerdata.com/blog/pgvector-vs-qdrant

구현 과정은 이렇습니다:

1단계: PostgreSQL + pgvector 설치

기존에 H2 인메모리 DB를 쓰고 있었는데, 벡터 검색을 위해 PostgreSQL로 마이그레이션했습니다.

pgvector는 PostgreSQL의 확장 기능으로, 벡터 데이터를 저장하고 검색할 수 있게 해줍니다.

2단계: 텔레그램 메시지 임베딩

모든 텔레그램 메시지를 768차원 벡터로 변환해서 DB에 저장합니다. Ollama의 임베딩 모델을 사용했어요.

멀티스레드로 분석 속도 향상

RAG를 도입하니 또 다른 문제가 생겼습니다. 한 종목당 임베딩 + 벡터 검색 + AI 분석 시간이 1.5초 정도 걸리는데, 종목이 10개면 15초나 걸립니다.

해결책은 멀티스레드였습니다. 5개 스레드로 병렬 처리하니 10개 종목을 3초 안에 분석할 수 있게 됐습니다.

인덱싱 최적화

HNSW(Hierarchical Navigable Small World) 인덱스를 채택하였습니다. 정확도는 약간 희생되지만 실시간 거래에서는 속도가 더 중요합니다.

컨텍스트 윈도우 전략

처음엔 관련 메시지를 무조건 10개씩 가져왔는데, 너무 많은 정보가 오히려 AI를 헷갈리게 만들었습니다.

실험 결과 최적의 설정은:

최근 7일 이내
유사도 상위 5개
코사인 유사도 0.7 이상만

실제 코드(일부)

@Configuration
class VectorStoreConfig {

    @Bean
    fun embeddingModel(): EmbeddingModel {
        val openAiApi = OpenAiApi.builder()
            .baseUrl("http://localhost:11434")  // Ollama 서버
            .apiKey("ollama")  // 더미 키
            .build()

        return OpenAiEmbeddingModel(
            openAiApi,
            org.springframework.ai.document.MetadataMode.EMBED,
            OpenAiEmbeddingOptions.builder()
                .model("nomic-embed-text")  // 768차원 임베딩 모델
                .build(),
            RetryUtils.DEFAULT_RETRY_TEMPLATE,
        )
    }
}

fun embedMessage(message: ChannelMessage) {
    // 메시지 내용 + 이미지 분석 결과 결합
    val content = message.content + 
        if (message.imageAnalysis != null) "\n[이미지 분석] ${message.imageAnalysis}" else ""
    
    // 메타데이터 구성
    val metadata = mutableMapOf<String, Any>(
        "channelName" to message.channelName,
        "createdAt" to message.createdAt.toString(),
        "stockCode" to message.matchedStockCode,
        "stockName" to message.matchedStockName,
        "type" to "channel_message"
    )
    
    // Spring AI Document로 변환 후 저장
    val document = Document(content, metadata)
    vectorStore.add(listOf(document))
}

fun searchRelatedMessages(
    stockName: String,
    stockCode: String,
    sectorName: String? = null,
    topK: Int = 8,
    similarityThreshold: Double = 0.5,
    daysBack: Long = 7L
): List<RelevantMessage> {
    
    // 검색 쿼리: 종목명 + 섹터명 + "관련 뉴스 소식"
    val query = "$stockName ${sectorName ?: ""} 관련 뉴스 소식"
    
    // 시간 필터: 최근 7일 이내
    val sinceDate = LocalDateTime.now().minusDays(daysBack).toString()
    val filterExpression = "createdAt >= '$sinceDate'"
    
    // 벡터 검색 실행
    val request = SearchRequest.builder()
        .query(query)
        .topK(topK)
        .similarityThreshold(similarityThreshold)  // 0.5 이상만
        .filterExpression(filterExpression)
        .build()
    
    return vectorStore.similaritySearch(request)
}

@Scheduled(cron = "0 0 4 * * *")  // 매일 오전 4시
fun cleanupOldEntries() {
    val cutoffDate = LocalDateTime.now().minusDays(30).toString()
    
    jdbcTemplate.update(
        "DELETE FROM vector_store WHERE metadata->>'createdAt' < ? AND metadata->>'type' = 'channel_message'",
        cutoffDate
    )
}

배운 점

1. RAG는 LLM의 게임 체인저: 같은 모델이라도 컨텍스트 유무에 따라 성능이 12% 이상 차이 납니다.

2. 벡터 DB 선택이 중요: 처음엔 Chroma, Qdrant 같은 전용 벡터 DB를 고려했지만, pgvector로도 충분했습니다.

3. 임베딩 모델 선택: 로컬 모델 nomic-embed-text(768차원)을 사용하였습니다. 한국어 성능은 약간 떨어지지만 실시간 처리엔 문제없었어요.

AI 자동매매 시스템 만들기 #4 - AI가 실제로 판단하는 방법

Kua — Thu, 12 Feb 2026 14:53:01 +0900

나의 로컬 LLM은?

사실 첫번째엔 Gemma3를 쓰고자 하였습니다.

근데 AI가 Gemma3 보다는 qwen을 추천한데요... 저보다 똑똑한 AI가 하는 말을 믿고 모델을 변경하였습니다.

와 동시에 vLLM에서 Ollama로 프레임워크를 변경하였습니다.

사유는 vLLM으로 동일 모델을 Windows 환경에서 구동하기 위해서는 WSL Linux에서 구동하거나 Docker를 이용하는 것이었습니다. 하지만 Docker로 구동을 하니 GPU 액셀러레이션을 제대로 활용하지 못해 속도가 굉장히 느렸습니다. (Linux OS 였다면 vLLM으로 했을 것입니다)

최종적으로 Ollama를 사용해서 Qwen3 14B 모델을 로컬 서버에서 실행합니다.

ollama run qwen3:14b

응답 속도는 0.5초 이하, 비용은 전기세뿐. API 호출 제한도 없습니다!

모델 선정에는 아래 블로그를 참조하였습니다

https://www.glukhov.org/ko/post/2026/01/choosing-best-llm-for-ollama-on-16gb-vram-gpu/

AI 분석 프롬프트 설계

AI에게 "이 주식 살까요?"라고 물으면 제대로 된 답이 안 나옵니다. 구조화된 프롬프트가 필요합니다.

AI에게 필요한 모든 정보를 주고, 명확한 형식으로 답변을 요구합니다.

val prompt = """
You are an AI trading analyst for the Korean stock market.
Analyze the following stock and decide whether to BUY, HOLD, or SELL.

## Stock Information
- Name: ${stockName}
- Code: ${stockCode}
- Current Price: ${currentPrice}원
- Change: ${changeRate}%
- Volume: ${volume} (평균 대비 ${volumeRatio}배)

## Technical Indicators
- RSI(14): ${rsi} ${when {
    rsi > 70 -> "(과매수 구간)"
    rsi < 30 -> "(과매도 구간)"
    else -> ""
}}
- MACD: ${macd} / Signal: ${signal} ${if (macd > signal) "(상승 추세)" else "(하락 추세)"}
- 20일 이동평균: ${ma20}원 (현재가 대비 ${maDiff}%)

## Recent News from Channels
${channelMessages.joinToString("\n") { "- ${it.timestamp}: ${it.text}" }}

## Account Status
- Available Cash: ${availableCash}원
- Current Holdings: ${holdings.size}개 종목
- Total Portfolio Value: ${totalValue}원

## Decision Rules
- Only BUY if confidence >= 70% and riskLevel is LOW or MEDIUM
- Set SELL if technical indicators show clear downtrend
- Use HOLD for uncertain situations

## Response Format (JSON only)
{
  "decision": "BUY" | "HOLD" | "SELL",
  "confidence": 0-100,
  "riskLevel": "LOW" | "MEDIUM" | "HIGH",
  "reason": "간단한 한국어 설명 (2-3문장)",
  "targetPrice": 목표가 (매수시에만),
  "stopLoss": 손절가 (매수시에만)
}
""".trimIndent()

실제 AI 호출 코드:

@Service
class AiAnalysisService(
    private val chatClient: ChatClient
) {
    fun analyzeStock(stockCode: String): AnalysisResult? {
        val prompt = buildPrompt(stockCode)
        
        val response = chatClient.prompt()
            .user(prompt)
            .call()
            .content()
        
        return parseAiResponse(response)
    }
}

Spring AI 덕분에 LLM 호출이 한 줄로 끝납니다. Retry 로직, 타임아웃, 스트리밍도 쉽게 추가할 수 있어요.

JSON 파싱의 함정

AI가 항상 완벽한 JSON을 반환할까요? 아닙니다!

가끔 앞뒤로 설명을 붙이는 거죠. 그래서 파싱 로직을 견고하게 만들어야 합니다.

3단계 폴백 전략으로 AI 응답을 안정적으로 파싱합니다.

기술적 지표 계산

AI에게 차트를 그대로 보여줄 수는 없으니, 기술적 지표를 계산해서 숫자로 전달합니다.

RSI(상대강도지수), MACD(이동평균수렴확산) 같은 지표들을 계산해서 AI 프롬프트에 포함시켜서 판단 근거로 활용합니다.

실시간 손절/익절

초기에는 1분마다 폴링해서 가격을 체크했습니다. 문제는 1분 사이에 급락하면 손절 타이밍을 놓친다는 거죠.

그래서 WebSocket 실시간 체결 데이터를 활용합니다. 체결 데이터가 오는 즉시 손절/익절 조건을 체크하고, 조건이 맞으면 바로 매도합니다. 폴링 방식 대비 최대 60배 빠른 반응 속도입니다!

거래 정지 알림 - SYSTEM 메시지 활용

WebSocket에는 체결 데이터 외에도 SYSTEM 메시지가 옵니다. 거래 정지/재개 같은 중요한 이벤트죠.

거래 정지되면 즉시 텔레그램으로 알림이 옵니다. 손해를 막을 수 있는 중요한 기능이죠.

Vision AI - 이미지 뉴스 분석

텔레그램 채널에 차트 이미지나 뉴스 스크린샷이 올라오는 경우가 있습니다. 이것도 분석해야죠!

Ollama의 Vision 모델(qwen3-vl:8b)을 사용합니다. 텔레그램에서 사진이 오면 이미지 다운로드 → Vision AI로 분석 → 텍스트 추출 + 요약 → DB에 저장합니다.

이제 차트 이미지도 놓치지 않습니다!

배운 점들

1. 로컬 AI는 생각보다 강력하다

ChatGPT만 AI가 아닙니다. 로컬에서 돌리는 오픈소스 LLM도 충분히 실용적입니다.

2. 프롬프트 설계가 전부다

"주식 사줘"가 아니라 구조화된 정보를 주고, 명확한 형식을 요구해야 합니다.

3. AI 응답은 불안정하다

항상 완벽한 JSON이 오지 않습니다. 폴백 파싱 로직이 필수입니다.

4. 실시간은 WebSocket이 답이다

폴링으로는 빠른 시장 변화를 따라갈 수 없습니다. WebSocket 실시간 데이터가 핵심입니다.

5. Vision AI는 보너스

이미지 뉴스도 분석하면 정보 손실이 줄어듭니다. 생각보다 정확도가 높아요.

다음 글 예고

오늘은 AI 분석 시스템과 실시간 거래 로직에 대해 이야기했습니다. 다음 글에서는:

PostgreSQL + pgvector로 RAG 구축하기
과거 뉴스를 벡터 검색해서 AI 컨텍스트에 추가
포트폴리오 자동 리포트 생성
실전 투자 전환과 최종 개선 사항

AI 자동매매 시스템 만들기 #3 - 키움증권 API 연동과 실전 거래

Kua — Thu, 12 Feb 2026 14:04:15 +0900

API 연동 삽질기 - 토큰 관리의 중요성

키움 REST API는 OAuth 2.0 방식을 씁니다. access_token과 refresh_token을 발급받아서 쓰는 구조입니다.

access_token은 24시간 유효, refresh_token은 30일 유효

문제는 토큰이 만료되면 자동매매가 멈춘다는 거죠. 그래서 토큰 갱신 로직을 반드시 구현해야 합니다.

@Service
class KiwoomAuthService(
    private val kiwoomProperties: KiwoomProperties,
    private val webClient: WebClient,
) {
    @Volatile
    private var accessToken: String? = null
    @Volatile
    private var refreshToken: String? = null
    @Volatile
    private var tokenExpiry: LocalDateTime? = null

    fun getAccessToken(): String {
        // 토큰이 없거나 만료 임박(10분 이내)이면 갱신
        if (accessToken == null || isTokenExpiringSoon()) {
            refreshAccessToken()
        }
        return accessToken ?: throw IllegalStateException("토큰 없음")
    }

    private fun isTokenExpiringSoon(): Boolean {
        val expiry = tokenExpiry ?: return true
        return LocalDateTime.now().plusMinutes(10).isAfter(expiry)
    }

    private fun refreshAccessToken() {
        val response = webClient.post()
            .uri("/oauth/token")
            .bodyValue(mapOf(
                "grant_type" to "refresh_token",
                "refresh_token" to refreshToken,
                "client_id" to kiwoomProperties.appKey,
                "client_secret" to kiwoomProperties.appSecret
            ))
            .retrieve()
            .bodyToMono(TokenResponse::class.java)
            .block()

        accessToken = response?.accessToken
        tokenExpiry = LocalDateTime.now().plusSeconds(response?.expiresIn ?: 86400)
    }
}

토큰 만료 10분 전에 미리 갱신하도록 했습니다. 장 중에 토큰이 만료되면 거래를 못하니까요!

API 호출 제한 - Rate Limiter 구현

키움 API에는 호출 제한이 있습니다:

초당 최대 20회
분당 최대 200회
시간당 최대 1,000회

이 제한을 넘으면 일시적으로 API 사용이 차단됩니다. 그래서 Rate Limiter를 만들었습니다:

@Component
class KiwoomRateLimiter {
    private val buckets = ConcurrentHashMap<String, RateLimitBucket>()

    fun acquire(apiId: String) {
        val bucket = buckets.computeIfAbsent(apiId) {
            RateLimitBucket(
                perSecond = 20,
                perMinute = 200,
                perHour = 1000
            )
        }

        while (!bucket.tryAcquire()) {
            Thread.sleep(50)  // 50ms 대기 후 재시도
        }
    }

    private class RateLimitBucket(
        private val perSecond: Int,
        private val perMinute: Int,
        private val perHour: Int,
    ) {
        private val secondWindow = LinkedList<Long>()
        private val minuteWindow = LinkedList<Long>()
        private val hourWindow = LinkedList<Long>()

        @Synchronized
        fun tryAcquire(): Boolean {
            val now = System.currentTimeMillis()

            // 오래된 기록 정리
            cleanup(secondWindow, now - 1000)
            cleanup(minuteWindow, now - 60000)
            cleanup(hourWindow, now - 3600000)

            // 제한 확인
            if (secondWindow.size >= perSecond) return false
            if (minuteWindow.size >= perMinute) return false
            if (hourWindow.size >= perHour) return false

            // 기록 추가
            secondWindow.add(now)
            minuteWindow.add(now)
            hourWindow.add(now)
            return true
        }

        private fun cleanup(window: LinkedList<Long>, threshold: Long) {
            while (window.isNotEmpty() && window.first < threshold) {
                window.removeFirst()
            }
        }
    }
}

슬라이딩 윈도우 방식으로 구현했습니다. API 호출 전에 acquire()를 호출하면 자동으로 제한을 지켜줍니다.

WebSocket으로 장 상태 실시간 감지

REST API만으로는 현재 장이 열려있는지 닫혀있는지 알 수 없습니다. 매번 API를 호출해서 확인하면 비효율적이고요.

그래서 WebSocket을 사용합니다. 키움은 실시간 시세와 장 상태를 WebSocket으로 제공합니다:

@Service
class KiwoomMarketStateService(
    private val kiwoomWebSocketClient: WebSocketClient,
    private val kiwoomWebSocketUrl: String,
    private val authService: KiwoomAuthService,
) {
    private val connected = AtomicBoolean(false)
    private val activePhases = ConcurrentHashMap.newKeySet<MarketPhase>()

    @PostConstruct
    fun init() {
        activePhases.add(MarketPhase.CLOSED)
        connect()
    }

    private fun connect() {
        kiwoomWebSocketClient.execute(URI.create(kiwoomWebSocketUrl)) { session ->
            handleSession(session)
        }
            .retryWhen(
                Retry.backoff(100, Duration.ofSeconds(5))
                    .maxBackoff(Duration.ofSeconds(60))
            )
            .subscribe()
    }

    private fun handleSession(session: WebSocketSession): Mono<Void> {
        connected.set(true)

        // LOGIN 전문 전송
        val loginMessage = buildLoginMessage()
        val sendMono = session.send(Mono.just(session.textMessage(loginMessage)))

        // 실시간 메시지 수신
        val receiveMono = session.receive()
            .map(WebSocketMessage::getPayloadAsText)
            .flatMap { payload -> processMessage(payload, session) }
            .then()

        return sendMono.thenMany(receiveMono).then()
    }
}

WebSocket이 끊기면 자동으로 재연결합니다. 최대 100회까지 5초 간격으로 재시도하고, 그래도 실패하면 텔레그램으로 알림을 보냅니다.

장 상태 코드 해석

키움 API는 장 상태를 숫자 코드로 보내줍니다:

215 = 장운영구분
- 01: 장 시작 전
- 02: 정규장 시작
- 03: 정규장 마감
- 04: 시간외 종가
- 등등...

문제는 KRX(일반 주식), NXT(야간 거래), 시간외 거래가 각각 독립적으로 움직인다는 겁니다.

enum class MarketStateCode(val code: String, val description: String) {
    PRE_MARKET_ALERT("01", "장 시작 전"),
    MARKET_OPEN("02", "정규장 시작"),
    MARKET_CLOSE("03", "정규장 마감"),
    REGULAR_CLOSE("08", "정규장 마감 확정"),

    AFTER_HOURS_CLOSING_START("04", "시간외 종가 시작"),
    AFTER_HOURS_CLOSING_END("05", "시간외 종가 종료"),
    AFTER_HOURS_SINGLE_START("06", "시간외 단일가 시작"),
    AFTER_HOURS_SINGLE_END("07", "시간외 단일가 종료"),

    NXT_PRE_MARKET_START("11", "NXT 프리마켓 시작"),
    NXT_PRE_MARKET_END("12", "NXT 프리마켓 종료"),
    NXT_MAIN_MARKET_START("21", "NXT 메인마켓 시작"),
    NXT_MAIN_MARKET_END("22", "NXT 메인마켓 종료"),
    NXT_AFTER_MARKET_START("31", "NXT 에프터마켓 시작"),
    NXT_AFTER_MARKET_END("32", "NXT 에프터마켓 종료"),

    ALL_CLOSE("99", "전체 마감"),
    UNKNOWN("00", "알 수 없음");
}

여러 장이 동시에 열릴 수 있어서, Set으로 관리합니다:

private val activePhases = ConcurrentHashMap.newKeySet<MarketPhase>()

fun isKrxOpen(): Boolean = MarketPhase.KRX_OPEN in activePhases

fun isNxtOpen(): Boolean =
    MarketPhase.NXT_PRE_MARKET in activePhases ||
    MarketPhase.NXT_MAIN_MARKET in activePhases ||
    MarketPhase.NXT_AFTER_MARKET in activePhases

fun isAnyMarketOpen(): Boolean = isKrxOpen() || isNxtOpen()

이제 다른 서비스에서 간단하게 확인할 수 있습니다:

if (!marketStateService.isKrxOpen()) {
    logger.info { "장 마감 중 — 주문 스킵" }
    return
}

실제 주문 실행

드디어 실제로 주문을 넣는 코드를 만들 차례입니다.

@Service
class KiwoomOrderService(
    private val apiClient: KiwoomApiClient,
    private val marketStateService: KiwoomMarketStateService,
) {
    fun buyStock(
        accountNumber: String,
        stockCode: String,
        quantity: Int,
        price: Long,
        exchangeType: ExchangeType = ExchangeType.KRX,
    ): String? {
        // 1. 장 상태 확인
        if (!marketStateService.canTrade(exchangeType)) {
            logger.warn { "[$stockCode] 현재 거래 불가 상태 (exchange=$exchangeType)" }
            return null
        }

        // 2. 주문 가능 금액 확인
        val deposit = accountService.getDeposit()
        val orderableAmount = KiwoomNumberParser.parseLong(deposit?.output?.orderableAmount)
        val totalCost = price * quantity

        if (totalCost > orderableAmount) {
            logger.warn { "[$stockCode] 주문 가능 금액 부족: $totalCost > $orderableAmount" }
            return null
        }

        // 3. 주문 실행
        val response = apiClient.callApi<KiwoomOrderResponse>(
            apiId = "ka10007",
            uri = "/api/dotr/order",
            body = mapOf(
                "acno" to accountNumber,
                "stk_cd" to stockCode,
                "buy_sell_tp" to "1",  // 1=매수
                "ord_qty" to quantity.toString(),
                "ord_pric" to price.toString(),
                "ord_tp" to "00",  // 00=지정가
                "excg_tp" to exchangeType.code,
            ),
            label = "매수 주문 [$stockCode]",
        )

        return response?.orderNumber
    }
}

주문 전에 반드시 확인하는 것들:

장이 열려있는가?
주문 가능 금액이 충분한가?
입력값이 올바른가? (음수, 0 등 체크)

모의투자 vs 실전 - Profile로 분리

처음부터 실전 계좌로 테스트할 수는 없습니다. 그래서 Spring Profile로 환경을 분리했습니다:

spring:
  profiles:
    active: mock  # 또는 real

kiwoom:
  mock:
    url: https://mock.kiwoom.com
    app-key: ${MOCK_APP_KEY}
  real:
    url: https://api.kiwoom.com
    app-key: ${REAL_APP_KEY}

애플리케이션 시작 시 Profile을 검증합니다:

@Component
class ProfileValidator(
    private val environment: Environment
) : ApplicationRunner {
    override fun run(args: ApplicationArguments) {
        val profiles = environment.activeProfiles
        val validProfiles = setOf("mock", "real")

        if (profiles.none { it in validProfiles }) {
            logger.error { "잘못된 프로파일: $profiles" }
            logger.error { "반드시 'mock' 또는 'real' 프로파일을 지정하세요" }
            exitProcess(1)
        }

        logger.info { "실행 환경: ${profiles.joinToString()}" }
    }
}

프로파일을 안 주거나 잘못 주면 아예 실행을 안 합니다.

주문 체결 추적 - WebSocket 활용

주문을 넣으면 바로 체결되는 게 아닙니다. 시장 상황에 따라 몇 초 ~ 몇 분 걸릴 수 있죠.

WebSocket으로 주문 체결 상태를 실시간으로 받을 수 있습니다:

@Service
class KiwoomOrderTrackingService(
    private val marketStateService: KiwoomMarketStateService,
) {
    private val pendingOrders = ConcurrentHashMap<String, OrderStatus>()

    @PostConstruct
    fun init() {
        // 주문체결 실시간 리스너 등록
        marketStateService.addOrderExecutionListener { data ->
            handleExecutionUpdate(data)
        }
    }

    fun trackOrder(orderNumber: String, stockCode: String, orderType: String) {
        pendingOrders[orderNumber] = OrderStatus(
            stockCode = stockCode,
            orderType = orderType,
            status = "대기중",
            createdAt = LocalDateTime.now()
        )
    }

    private fun handleExecutionUpdate(data: JsonNode) {
        val orderNumber = data.get("values")?.get("주문번호")?.asText() ?: return
        val status = data.get("values")?.get("체결여부")?.asText() ?: return

        val order = pendingOrders[orderNumber] ?: return

        when (status) {
            "체결" -> {
                logger.info { "[${order.stockCode}] 주문 체결 완료: $orderNumber" }
                pendingOrders.remove(orderNumber)
                // DB에 거래 이력 저장
                saveTradeHistory(order, data)
            }
            "취소" -> {
                logger.warn { "[${order.stockCode}] 주문 취소됨: $orderNumber" }
                pendingOrders.remove(orderNumber)
            }
        }
    }
}

주문을 넣으면 추적 목록에 등록하고, WebSocket으로 체결 통지가 오면 DB에 저장합니다.

에러 처리 - 실패에 대비하기

API 호출은 언제든 실패할 수 있습니다:

네트워크 오류
API 서버 장애
토큰 만료
일시적인 과부하

그래서 모든 API 호출을 try-catch로 감싸고, 실패 시 로그를 남깁니다:

inline fun <reified T> callApi(
    apiId: String,
    uri: String,
    body: Map<String, Any>,
    label: String,
): T? {
    return try {
        rateLimiter.acquire(apiId)

        val response = webClient.post()
            .uri(uri)
            .header("Authorization", "Bearer ${authService.getAccessToken()}")
            .bodyValue(body)
            .retrieve()
            .bodyToMono(T::class.java)
            .timeout(Duration.ofSeconds(10))
            .block()

        logger.debug { "$label 성공" }
        response
    } catch (e: WebClientResponseException) {
        logger.error { "$label 실패: HTTP ${e.statusCode} - ${e.responseBodyAsString}" }
        null
    } catch (e: TimeoutException) {
        logger.error { "$label 타임아웃 (10초 초과)" }
        null
    } catch (e: Exception) {
        logger.error(e) { "$label 오류" }
        null
    }
}

10초 타임아웃을 걸어서 무한 대기를 방지하고, 실패하면 null을 반환합니다.

실제 커밋 히스토리

이 기능들을 만들면서 남긴 커밋들:

b578174 - Add improved error handling and thread-safe token management
  └─ 토큰 갱신 로직 개선
     스레드 안전성 확보
     에러 처리 강화

2a4a94f - Add Kiwoom WebSocket for real-time market state updates
  └─ WebSocket 연결 구현
     장 상태 실시간 감지
     KRX/NXT/SOR 거래소 로직

WebSocket 구현이 생각보다 까다로웠습니다. 연결이 끊겼다 재연결할 때 LOGIN부터 다시 해야 하는 등의 디테일이 많았거든요.

배운 점들

1. 금융 API는 엄격하다

토큰 만료, 호출 제한, 장 시간 제약 등 지켜야 할 규칙이 많습니다. 하나라도 놓치면 거래가 안 되거나 계정이 일시 정지될 수 있어요.

2. 실시간 연결은 불안정하다

WebSocket 연결은 언제든 끊길 수 있습니다. 자동 재연결 로직은 필수입니다.

3. Profile 분리로 실수 방지

코드 한 줄만 바꿔서 mock↔real을 전환하면 위험합니다. 명시적인 Profile 설정으로 실수를 방지해야 합니다.

4. 로그가 생명이다

거래 로직에서 뭔가 잘못되면 로그를 보고 추적해야 합니다. 모든 주요 동작을 로그로 남기세요.

다음 글 예고

오늘은 키움증권 API 연동과 실제 거래 구현에 대해 이야기했습니다. 다음 글에서는:

AI가 실제로 어떻게 매매 판단을 내리는지
기술적 지표 계산 로직
백테스팅으로 전략 검증하기
실전 투자 결과와 개선 사항

이런 내용들을 다뤄볼 예정입니다. 실제로 AI가 어떤 판단을 내렸고 결과는 어땠는지 공유하겠습니다!

AI 자동매매 시스템 만들기 #2 - 채널 모니터링과 5단계 매칭 시스템

Kua — Thu, 12 Feb 2026 00:24:20 +0900

지난 글에서는 프로젝트 구조와 설계에 대해 이야기했는데요, 오늘은 가장 재미있었던 부분인 텔레그램 채널 모니터링 기능 구현에 대해 이야기해보려고 합니다.

왜 텔레그램 채널을 모니터링하나?

출처: Nano Banana

주식 투자를 하다 보면 여러 텔레그램 채널을 구독하게 됩니다. 증권사 리포트 채널, 뉴스 속보 채널, 개별 종목 분석 채널 등등... 문제는 이 채널들에서 쏟아지는 정보를 실시간으로 다 확인하기 어렵다는 거죠.

"내가 관심 있는 종목에 대한 소식만 골라서 알림을 받을 수 있다면?"

이런 생각에서 시작했습니다. AI가 채널 메시지를 읽고, 내가 감시 중인 종목과 관련이 있는지 판단해서 알려주면 좋겠다는 거죠.

TDLib - 텔레그램의 공식 라이브러리

텔레그램 봇 API를 쓸까 하다가, 더 강력한 방법을 찾았습니다. 바로 TDLib입니다.

TDLib(Telegram Database Library)는 텔레그램이 공식적으로 제공하는 C++ 라이브러리인데요, 봇 API와는 달리 일반 사용자처럼 동작할 수 있습니다. 즉, 내가 직접 가입한 채널들의 메시지를 실시간으로 받아볼 수 있죠.

다만 한 가지 문제가 있었습니다. Java/Kotlin에서 쓸 수 있는 JNI 바인딩이 필요한데, Windows에서 빌드하는 게 생각보다 까다로웠어요.

TDLib Windows 빌드 삽질기

많은 수행 착오를 겪었습니다.
1. Visual Studio 2022 필요
2. vcpkg로 의존성 설치 (openssl, zlib 등)
3. CMake로 빌드
4. Java JNI 바인딩까지 포함해서 컴파일

10번 이상 시도 끝에 또 실패인가 하던 순간..

너무 이쁜 초록 글씨 발생!

채널 모니터링 서비스 구조

이제 본격적으로 코드를 볼까요? 채널 모니터링 서비스의 핵심 구조입니다:

@Service
@ConditionalOnProperty(name = ["tdlib.api-id"], matchIfMissing = false)
class ChannelMonitorService(
    private val tdLibProperties: TdLibProperties,
    private val channelMessageRepository: ChannelMessageRepository,
    private val watchStockRepository: WatchStockRepository,
    @param:Qualifier("general")
    private val chatClient: ChatClient,
    private val braveSearchService: BraveSearchService? = null,
    private val tavilyService: TavilyService? = null,
) {
    private var client: Client? = null
    private val authorized = AtomicBoolean(false)
    private val channelChatIds = ConcurrentHashMap<Long, String>()

    @PostConstruct
    fun init() {
        // TDLib 네이티브 라이브러리 로딩
        loadNativeLibraries()

        // 클라이언트 생성
        client = Client.create(
            { update -> handleUpdate(update) },
            { e -> logger.error(e) { "TDLib 에러" } },
            { e -> logger.error(e) { "TDLib 기본 에러" } },
        )
    }
}

ConditionalOnProperty를 써서 TDLib 설정이 없으면 이 기능 자체를 비활성화하도록 했습니다. 개발 환경에서는 끄고 싶을 때가 있거든요.

5단계 매칭 시스템

채널 메시지를 받으면, 내가 감시 중인 종목과 관련이 있는지 5단계로 판단합니다:

1차: 직접 매칭

가장 간단한 방법입니다. 메시지에 종목명이나 종목코드가 직접 나오는지 확인합니다.

private fun findDirectMatches(text: String, watchStocks: List<WatchStock>): List<WatchStock> =
    watchStocks.filter { stock ->
        text.contains(stock.stockName) || text.contains(stock.stockCode)
    }

"삼성전자 실적 발표" → 삼성전자 매칭!

2차: 섹터 키워드 매칭

종목을 섹터별로 분류하고, 각 섹터마다 키워드를 등록해뒀습니다. 메시지에 해당 키워드가 있으면 그 섹터의 모든 종목을 매칭합니다.

private fun findSectorMatches(
    text: String,
    watchStocks: List<WatchStock>,
    alreadyMatched: Set<WatchStock>,
): List<WatchStock> {
    val allKeywords = sectorKeywordRepository.findAll()
    val textLower = text.lowercase()

    val matchedSectorIds = allKeywords
        .filter { kw -> textLower.contains(kw.keyword.lowercase()) }
        .map { it.sector.id }
        .toSet()

    return watchStocks.filter { stock ->
        stock !in alreadyMatched && stock.sector?.id in matchedSectorIds
    }
}

"반도체 수출 증가" → 반도체 섹터의 모든 종목 매칭!

3차: AI 연관성 판단

1차, 2차에서 걸러지지 않은 메시지는 AI에게 물어봅니다.

private fun findLlmMatches(text: String, watchStocks: List<WatchStock>): List<WatchStock> {
    val stockList = watchStocks.joinToString("\n") { "- ${it.stockName}(${it.stockCode})" }
    val prompt = """
        아래 뉴스/메시지가 어떤 종목에 영향을 줄 수 있는지 판단하세요.
        관련 없으면 빈 배열을 반환하세요.

        ## 감시 종목 목록
        $stockList

        ## 메시지
        ${text.take(1000)}
    """.trimIndent()

    val result = chatClient.prompt()
        .user(prompt)
        .call()
        .entity(ChannelMatchResult::class.java)
        ?: return emptyList()

    return watchStocks.filter { it.stockCode in result.relatedStockCodes }
}

"전기차 배터리 화재 논란" → AI가 LG에너지솔루션, SK온 등을 연관 지음

4차: 웹 검색 보강 (Brave Search)

메시지만으로는 맥락이 부족할 때가 있습니다. 이럴 때는 웹 검색을 해서 추가 정보를 얻습니다.

private fun findBraveMatches(text: String, watchStocks: List<WatchStock>): List<WatchStock> {
    // AI가 검색 쿼리 생성
    val refinement = refineBraveQuery(text)
    if (refinement == null || !refinement.worthSearching) {
        return emptyList()
    }

    // Brave API로 웹 검색
    val results = braveSearchService?.searchWeb(
        refinement.searchQuery,
        count = 3,
        freshness = "pd"  // past day
    ) ?: return emptyList()

    // 검색 결과에서 종목명 찾기
    val allText = results.joinToString(" ") {
        "${it.title ?: ""} ${it.description ?: ""}"
    }

    return watchStocks.filter { stock ->
        allText.contains(stock.stockName) || allText.contains(stock.stockCode)
    }
}

중요한 점: 모든 메시지에 대해 웹 검색을 하면 비용이 너무 많이 나갑니다. 그래서 AI에게 먼저 "이 메시지가 검색할 가치가 있나?"를 물어봅니다.

private fun refineBraveQuery(text: String): BraveQueryRefinementResult? {
    val prompt = """
        아래 텔레그램 채널 메시지를 분석하여 주식 종목 관련 웹 검색 쿼리를 만들어주세요.

        ## 규칙
        1. 특정 기업/종목/사건에 대한 메시지면 worthSearching=true
        2. 아래 유형은 worthSearching=false:
           - 코스피/코스닥 지수 마감/등락 속보
           - 일반 시황 요약
           - 단순 수치 나열

        ## 메시지
        ${text.take(500)}
    """.trimIndent()

    return chatClient.prompt()
        .user(prompt)
        .call()
        .entity(BraveQueryRefinementResult::class.java)
}

"코스피 2,600선 마감" → worthSearching=false (검색 안 함)
"○○기업 CEO 사퇴" → worthSearching=true (검색함)

5차: URL 본문 추출 (Tavily)

메시지에 URL이 포함되어 있으면, 그 링크의 실제 내용을 읽어봅니다.

private fun findTavilyUrlMatches(text: String, watchStocks: List<WatchStock>): List<WatchStock> {
    val urls = URL_PATTERN.findAll(text).map { it.value }.toList().take(2)
    if (urls.isEmpty()) return emptyList()

    val extracts = tavilyService?.extract(urls) ?: return emptyList()
    val allContent = extracts.joinToString(" ") { it.rawContent ?: "" }

    return watchStocks.filter { stock ->
        allContent.contains(stock.stockName) || allContent.contains(stock.stockCode)
    }
}

텔레그램 채널에 "속보 https://..." 이렇게만 올라오는 경우가 많거든요. 이럴 때 링크 안의 내용까지 확인합니다.

이미지도 분석한다

텔레그램 채널에는 차트 이미지, 뉴스 캡처 등이 많이 올라옵니다. 텍스트만 보면 놓치는 정보가 많아요.

그래서 Vision AI도 추가했습니다:

private fun analyzePhotoMessage(
    photoContent: TdApi.MessagePhoto,
    caption: String?,
): ImageAnalysisResult? {
    // 가장 큰 사이즈의 사진 선택
    val photoSize = photoContent.photo?.sizes
        ?.maxByOrNull { it.width * it.height }
        ?: return null

    // TDLib로 이미지 다운로드
    val localPath = downloadFileWithRetry(photoSize.photo.id)
        ?: return null

    val imageBytes = File(localPath).readBytes()

    // Vision AI로 분석
    return imageAnalysisService.analyzeImage(imageBytes, mimeType, caption)
}

차트 이미지가 올라오면 AI가 "이 차트는 ○○종목의 일봉 차트이며, 상승 추세를 보이고 있습니다"라고 분석해줍니다.

성능 최적화 - 캐싱

매 메시지마다 DB에서 감시 종목 목록을 조회하면 느립니다. 그래서 간단한 캐싱을 추가했습니다:

companion object {
    private const val WATCH_STOCKS_CACHE_TTL_MS = 3 * 60 * 1000L  // 3분
}

@Volatile
private var cachedWatchStocks: List<WatchStock> = emptyList()
@Volatile
private var watchStocksCacheTime: Long = 0L

private fun getActiveWatchStocks(): List<WatchStock> {
    val now = System.currentTimeMillis()
    if (now - watchStocksCacheTime > WATCH_STOCKS_CACHE_TTL_MS) {
        synchronized(this) {
            val nowInLock = System.currentTimeMillis()
            if (nowInLock - watchStocksCacheTime > WATCH_STOCKS_CACHE_TTL_MS) {
                cachedWatchStocks = watchStockRepository.findByActiveTrue()
                watchStocksCacheTime = System.currentTimeMillis()
            }
        }
    }
    return cachedWatchStocks
}

3분마다 한 번씩만 DB 조회하고, 그 사이에는 메모리의 캐시를 씁니다. 동시성 처리도 잊지 않았죠. (synchronized + double-check locking)

인증 처리 - REST API로

TDLib를 처음 쓸 때는 전화번호와 인증 코드 입력이 필요합니다. 터미널에서 입력받을 수도 있지만, REST API로 만들어서 더 편하게 했습니다:

fun submitAuthCode(code: String) {
    client?.send(TdApi.CheckAuthenticationCode().apply {
        this.code = code
    }) { result ->
        if (result is TdApi.Error) {
            logger.error { "인증 코드 실패: ${result.message}" }
        }
    }
}

서버 시작하고 로그에 이렇게 나옵니다:

========================================
텔레그램 인증 코드를 입력해주세요.
POST /api/tdlib/auth-code?code=XXXXX
========================================

그럼 Postman이나 curl로 코드 입력하면 됩니다. 편하죠?

실제 커밋 히스토리

이 기능을 만들면서 남긴 커밋들을 보면:

b2d6469 - Add Telegram channel monitoring via TDLib
  └─ 기본 채널 모니터링 기능
     TDLib 클라이언트 초기화
     메시지 수신 및 DB 저장

2bd4e8a - Add HTML support for Telegram messages
  └─ 텔레그램 메시지의 HTML 포맷 지원
     주식 거래 로직 검증 추가
     사용자 피드백 개선

처음에는 단순하게 만들고, 점점 기능을 추가해갔습니다.

그래서 어떻게 동작하나?

실제로 동작 했었던 모습을 말씀드리자면

1. 텔레그램 채널에 메시지 도착: "○○기업, 신규 수주 1,000억원 확보"
2. 1차 매칭 실패 (종목명 직접 언급 없음)
3. 2차 매칭 실패 (섹터 키워드 없음)
4. 3차 AI 판단: "○○기업은 감시 종목 중 ABC주식과 관련 있음"
5. DB에 저장:
   - message.content = "○○기업, 신규 수주..."
   - match.stockCode = "123456"
   - match.matchType = "LLM"
6. AI가 이 정보를 바탕으로 매매 판단

와 같은 모습이 되겠습니다.

배운 점들

1. 네이티브 라이브러리 연동은 생각보다 까다롭다
TDLib 빌드하느라 반나절을 썼습니다. 의존성 버전, 빌드 옵션... 한 번 성공하면 문서화해두는 게 중요해요.

2. 멀티스레드 환경에서의 캐싱 주의
TDLib는 콜백 방식이라 여러 스레드에서 동시에 메시지가 들어올 수 있습니다. synchronized와 volatile을 적절히 써야 합니다.

3. AI 호출 비용 최적화 필요
처음에는 모든 메시지에 대해 AI/웹검색을 했다가 비용이 급증했습니다. "검색할 가치가 있나?" 를 먼저 물어보는 게 중요합니다.

4. 5단계 매칭은 충분하다
처음에는 "더 복잡한 매칭 알고리즘이 필요하지 않을까?" 고민했는데, 5단계면 거의 모든 경우를 커버합니다.

다음 글 예고

오늘은 텔레그램 채널 모니터링 기능에 대해 이야기했습니다. 다음 글에서는:
- 키움증권 REST API 연동 과정
- 실시간 시세 수신 구현
- WebSocket 장 상태 감지
- 실제 매매 주문 실행 로직

이런 내용들을 다뤄볼 예정입니다. 실제로 돈이 오가는 부분이라 더 신중하게 만들었거든요!

AI 자동매매 시스템 만들기 #1 - 프로젝트의 시작과 설계

Kua — Wed, 11 Feb 2026 21:47:48 +0900

오늘부터 제가 만들고 있는 AI 자동매매 시스템 프로젝트 개발기를 연재하려고 합니다. 첫 번째 글에서는 프로젝트가 어떻게 시작되었고, 어떤 기술 스택을 선택했는지 이야기해볼게요.

왜 만들게 되었나?

1. 요즘 핫한 AI. 어떻게든 활용 능력을 키워보고 싶었습니다. (그래도 내가 백엔드 개발자인데...)

2. 과거 키움 증권의 Open API를 이용해서 구현을 시도하다가 32bit 프로그램을 포함한 다양한 디펜던시와 메인 PC에 깔아야 하는 보안 프로그램(매번 로그인도 번거로웠던).. 치를 떨고 줄행랑 쳤습니다. 그런데.... REST API가 나왔었더라구요!!

"AI가 객관적으로 판단해서 자동으로 매매하면 어떨까?"

물론 시중에 자동매매 프로그램들이 많이 있지만, 개발자로서 직접 만들어보고 싶었어요. 내가 원하는 방식으로 AI를 훈련시키고, 나만의 전략을 코드로 구현하는 재미도 있고요.

프로젝트 설계 - 어떻게 만들까?

일단 작게 프로젝트의 전체 그림을 그려봤습니다.

핵심 아키텍처

간단하게 설명하면 이렇습니다:

키움증권 REST API로 시세 정보를 가져옵니다
Spring Boot 서버가 중간에서 모든 로직을 처리합니다
vLLM으로 돌리는 로컬 AI 모델이 매매 판단을 내립니다
텔레그램 봇으로 알림을 받고 명령도 내릴 수 있습니다

여기서 중요한 결정이 하나 있었는데요, AI 모델을 외부 API가 아닌 로컬에서 돌리기로 했습니다.

왜 로컬 AI를 선택했나?

사실 고민을 할 이유도 없이 비용이죠. 사실 사이드 프로젝트인데 돈을 쓰고 싶지 않았습니다.

제 PC도 작은 모델을 돌리기에는 훌륭한 성능이었기 때문이기도 하구요!

그래서 선택한 모델이 Gemma 3 12B FP8 버전입니다. 12B 모델이면 충분히 똑똑하면서도 일반 게이밍 PC에서 돌릴 수 있거든요. vLLM으로 OpenAI API와 호환되는 형식으로 서빙하면, Spring AI에서 쉽게 연동할 수 있습니다.

최종 기술 스택 선택

Kotlin + Spring Boot 3.x: 자바 생태계의 강력함 + 코틀린의 간결함 (사실 현재 나의 메인 기술스택...)
Spring AI: AI 모델과의 통신을 쉽게 해주는 프레임워크
SQLite: 개인 프로젝트에는 가볍고 충분한 DB
Spring Scheduler: 주기적으로 매매 로직을 돌리기 위해
Telegram Bot: 모바일에서 알림 받고 명령 내리기

리스크 관리 설정

초기 커밋 직후 바로 추가한 게 리스크 관리 기능이었습니다. 이게 왜 중요하냐면:

한 종목에 너무 많은 돈을 넣으면 위험합니다
손실이 커지기 전에 자동으로 손절해야 합니다
수익이 나면 적당히 익절해야 합니다

실제 코드를 보시면 이런 설정들이 있어요:

@ConfigurationProperties(prefix = "trading.risk")
data class RiskProperties(
    val maxInvestmentPerStock: Long = 1_000_000,
    val stopLossRate: Double = -3.0,
    val takeProfitRate: Double = 5.0,
    val maxTotalInvestment: Long = 10_000_000,
    val buyConfidenceThreshold: Int = 70,
    val buyHighRiskConfidenceThreshold: Int = 85,
    val sellStopLossConfidenceThreshold: Int = 50,
    val sellTakeProfitConfidenceThreshold: Int = 65,
)

각 설정의 의미는:

종목당 최대 투자금: 100만원
총 투자 한도: 1000만원
손절 기준: -3%
익절 기준: +5%
AI 신뢰도 임계값: 매수는 70% 이상일 때만

AI가 아무리 "사라!"고 해도, 리스크 매니저가 "안 돼, 한도 초과야"라고 막을 수 있는 거죠. 중요한 안전장치입니다.

기술적 지표 계산

주식 분석에 쓰이는 기술적 지표들도 구현했습니다. AI에게 단순히 가격 데이터만 주는 게 아니라, 이미 계산된 기술적 지표를 함께 제공합니다:

SMA/EMA: 이동평균선 (추세 파악)
RSI: 과매수/과매도 판단
MACD: 매매 신호
볼린저 밴드: 변동성 측정
스토캐스틱: 모멘텀 지표

출처: https://tr.pinterest.com/pin/ema-vs-sma-understanding-the-differences--477451998010678524/

AI 분석 서비스 코드를 보면 이런 식으로 데이터를 수집합니다:

// 1. 종목 기본정보
val stockInfo = marketService.getStockInfo(stockCode)
val stockName = stockInfo.stockName!!
var currentPrice = KiwoomNumberParser.parseLong(stockInfo.currentPrice)

// 2. 일봉 차트 → OHLCV 데이터 추출
val dailyChart = marketService.getDailyChart(stockCode)
val candles = dailyChart?.output?.filter {
    KiwoomNumberParser.parseLong(it.closePrice).toDouble() > 0
} ?: emptyList()

val closes = candles.map { KiwoomNumberParser.parseLong(it.closePrice).toDouble() }
val highs = candles.map { KiwoomNumberParser.parseLong(it.highPrice).toDouble() }
val lows = candles.map { KiwoomNumberParser.parseLong(it.lowPrice).toDouble() }
val volumes = candles.map { KiwoomNumberParser.parseLong(it.volume).toDouble() }

// 3. 기술적 지표 계산
val indicators = if (closes.size >= 5) {
    TechnicalIndicator.analyzeWithOhlcv(closes, highs, lows, volumes)
} else {
    emptyMap()
}

이렇게 모은 데이터를 AI에게 프롬프트로 전달하면, AI는 이걸 보고 "지금 사야 할지 말지"를 판단합니다. 마치 사람이 차트를 보고 판단하는 것처럼요.

AI 분석 프롬프트 구조

AI에게 정보를 줄 때는 체계적으로 정리해서 줍니다:

private fun buildAnalysisPrompt(
    stockName: String,
    stockCode: String,
    currentPrice: Long,
    indicators: Map<String, Any?>,
    candles: List<DailyCandle>,
    holding: StockBalance?,
    pastDecisions: List<AiDecision>,
    channelMessages: List<ChannelMessage>,
    braveNews: List<BraveNewsResult>,
): String = buildString {
    appendLine("## 종목: $stockName ($stockCode)")
    appendLine("현재가: ${currentPrice}원")
    
    appendLine("## 기술적 지표")
    indicators.forEach { (k, v) -> appendLine("- $k: $v") }
    
    appendLine("## 최근 일봉 데이터")
    candles.take(10).forEach { c -> appendLine(formatCandle(c)) }
    
    if (holding != null) {
        appendLine("## 현재 보유")
        appendLine("- 수량: ${holding.holdingQty}")
        appendLine("- 평균매입가: ${holding.avgBuyPrice}")
        appendLine("- 수익률: ${holding.profitLossRate}%")
    }
    
    appendLine("## 텔레그램 채널 뉴스/소식")
    channelMessages.forEach { m -> 
        appendLine("- [${m.createdAt}] @${m.channelName}: ${m.content}")
    }
}

이렇게 정리된 정보를 받은 AI는 JSON 형식으로 판단을 내려줍니다:

{
  "decision": "BUY",
  "confidence": 75,
  "reasoning": "RSI가 30 이하로 과매도 구간이며, MACD 골든크로스 발생...",
  "targetPrice": 50000,
  "riskLevel": "MEDIUM"
}

개발 단계별 계획

처음 설계할 때 Phase별로 나눠놨습니다:

Phase 1-2: 프로젝트 기본 설정, 키움 인증
Phase 3-4: 시세 조회, 주문 실행
Phase 5-6: 기술적 지표 계산, AI 분석
Phase 7-8: 자동매매 스케줄러, REST API
Phase 9-10: 텔레그램 봇 (알림 + 자연어 명령)

각 단계를 명확하게 나누니까 개발하기가 훨씬 수월했습니다. "오늘은 Phase 3만 완성하자!" 이런 식으로 집중할 수 있었거든요.

실제 커밋 히스토리

첫날 커밋 로그를 보면:

c48b099 - Initial commit
  └─ 프로젝트 기본 구조, Spring Boot 설정
     AI 분석 서비스, 대시보드 컨트롤러
     키움/텔레그램 설정 파일들

b10a85f - Add risk management enhancements
  └─ 리스크 관리 설정 추가
     기술적 지표 확장

초기 커밋에서 이미 2,462줄의 코드가 들어갔네요. 미리 구조를 잘 잡아놓으니까 나중에 기능 추가하기가 훨씬 쉬웠습니다.

다음 글 예고

오늘은 프로젝트의 시작과 전체 설계에 대해 이야기했습니다. 다음 글에서는:

키움증권 API 연동 삽질기
텔레그램 봇 구현 과정
실제로 AI가 어떻게 판단하는지
텔레그램 채널 모니터링 구현

이런 내용들을 다뤄볼 예정입니다. 실제 코드와 함께 더 재미있는 이야기를 들려드릴게요!

혹시 궁금한 점이 있으시면 댓글로 남겨주세요. 다음 글에서 답변드리겠습니다!

2026 macOS 유틸

Kua — Mon, 19 Jan 2026 18:02:29 +0900

작성자의 주관이 포함된 게시글이며, 얼마든 대체제가 존재합니다.

인권 유틸

Homebrew

설명: 맥을 설치하면 반드시 맥주 한 잔!
공식 웹사이트: https://brew.sh/
라이선스: 무료 (BSD-2-Clause)

Keka

설명: Windows는 반디집. macOS는 케카
공식 웹사이트: https://www.keka.io/
라이선스: 무료

f.lux

설명: 소중한 눈을 지킵시다. mac의 기본 내장 기능(Night Shift)은 쓰레기입니다.
공식 웹사이트: https://justgetflux.com/
라이선스: 무료

문서 유틸

CotEditor

설명: Windows의 Notepad++ 대체 앱
공식 웹사이트: https://coteditor.com/
라이선스: 무료 (Apache-2.0)

draw.io

설명: 무료 중에선 원 탑 다이어그램 앱
공식 웹사이트: https://www.drawio.com/
라이선스: 무료 (Apache-2.0)

UpNote

설명: 노트 프로그램. (이것 저것 써보았으나, 다양한 생태계를 이용중인 저로서는 가장 적합한 솔루션이었습니다) 업데이트가 마음에 들어 영구라이선스 구매완료!
공식 웹사이트: https://getupnote.com/
라이선스: 부분 무료

Spark

설명: 최고의 이메일 통합 프로그램. 무료로도 충분히 이용 가능!
공식 웹사이트: https://sparkmailapp.com/
라이선스: 부분 무료

맞춤법 유틸

Matchumbeop

설명: 한국어 맞춤법
공식 웹사이트: https://matchumbeop.ssut.me/
라이선스: 무료 (Apache-2.0)

Refine

설명: 해외 프로그램이나, 더욱 사용성이 좋고 한국어 성능도 충분한 것으로 보임
공식 웹사이트: https://refine.sh/
라이선스: 유료 (7일 체험)

UX 유틸

Ice

설명: 작업표시줄을 Awesome하게!
공식 웹사이트: https://icemenubar.app/
라이선스: 무료 (GPL-3.0)

Scroll Reverser

설명: Windows OS를 더 오래써오신 분이라면 필수템. Logitech Options로도 변경해서 써보았으나 쓰는 시점에서 기억은 안나지만 치명적인 오류가 있어 이 프로그램을 사용하는게 훨씬 좋았음(훨씬 가볍기도 함)
공식 웹사이트: https://pilotmoon.com/scrollreverser/
라이선스: 무료 (Apache-2.0)

맥 인프라 유틸

AppCleaner

설명: 앱 깔끔하게 지우기
공식 웹사이트: https://freemacsoft.net/appcleaner/
라이선스: 무료

Clop

설명: 클립보드 최적화(이미지, 영상 압축)
공식 웹사이트: https://lowtechguys.com/clop/
라이선스: 부분 무료 (GPL-3.0)

개발자 유틸

개발자가 아니라면 굳이... 싶은 것들!

Gitify

설명: Github 알림 수신받기
공식 웹사이트: https://github.com/gitify-app/gitify
라이선스: 무료 (MIT)

Warp

설명: 터미널 프로그램. Terminal -> iTerm -> Ghost -> Warp 로 정착하였음
공식 웹사이트: https://www.warp.dev/
라이선스: 부분 무료

Raycast

설명: 인체 공학적 shortcut(Spotlight 대체). 2025년도부터 Alfred에서 갈아탔는데 강력합니다.
공식 웹사이트: https://www.raycast.com/
라이선스: 부분 무료

DevToys

설명: https://it-tools.tech/ 라는 대체제는 존재하나 설치형은 매우 빠르게 동작하며, 브라우저보다 최적화가 좋으며(메모리 누수가 적으며) 공학성이 뛰어납니다. 광고 없는 무료 프로그램중에는 탑이라 생각합니다.
공식 웹사이트: https://devtoys.app/
라이선스: 무료 (MIT)

크로스 OS 유저 유틸

input-leap

https://github.com/input-leap/input-leap

Spotify 유틸

Spotify Dedup

공식 웹사이트: https://spotify-dedup.com/
라이선스: 무료 (MIT)

Spicetify

설명: 스포티파이 클라이언트를 씹고 뜯고 맛보고 즐기고
공식 웹사이트: https://spicetify.app/
라이선스: 무료 (LGPL-2.1)

SpotX

설명: 광고 제거, 트래커 제거
공식 웹사이트: https://github.com/SpotX-Official/SpotX
라이선스: 무료 (MIT)

ivLyrics

설명: 노래들을때 영상도 보고, 해외 가사도 번역해서 보고싶다면! (한국인 맞춤형. 한국인 개발자.)
공식 웹사이트: https://github.com/ivLis-Studio/ivLyrics
라이선스: 무료 (LGPL-2.1)

Lyrs

설명: 알송 가사 플로팅 확장 (Musixmatch Plugin도 존재)
공식 웹사이트: https://github.com/organization/lyrs
라이선스: 무료 (Apache-2.0)

기타 유틸

Cyberduck

설명: macOS 최고의 무료 FTP 클라이언트
공식 웹사이트: https://cyberduck.io/
라이선스: 무료 (GPL-3.0)

Input Source Pro

설명: 번거로운 한영 전환 최소화. IME 전환 상태 표시기
공식 웹사이트: https://inputsource.pro/
라이선스: 무료 (GPL-3.0)

Karabiner

공식 웹사이트: https://karabiner-elements.pqrs.org/
라이선스: 무료 (The Unlicense)

Maccy

설명: 클립보드 히스토리 저장 프로그램. Raycast에도 있지만 이게 더 사용성이 좋고 유연함
공식 웹사이트: https://maccy.app/
라이선스: 무료 (MIT)

Shottr

설명: 스크린샷 + 그림판 프로그램. 너무 잘 쓰고 있어 저는 영구라이선스 구매하였습니다.
공식 웹사이트: https://shottr.cc/
라이선스: 유료 (30일 체험)

xray

설명: 요소 캡처 프로그램.
공식 웹사이트: https://github.com/wlswo/xray
라이선스: 무료 (GPL-3.0)

Spring boot RestClient H2C 설정

Kua — Wed, 23 Apr 2025 15:09:13 +0900

@Configuration
public class RestClientConfig {

    @Value("${...}")
    private String baseUrl;

    @Bean
    public RestClient restClient() {
        return RestClient.builder()
                .requestFactory(new JdkClientHttpRequestFactory(
                        HttpClient.newBuilder()
                                .version(HttpClient.Version.HTTP_2)
                                .build()
                ))
                .baseUrl(baseUrl)
                .defaultHeader("Content-Type", MediaType.APPLICATION_JSON_VALUE)
                .build();
    }
}