<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by chanyoung Kwon on Medium]]></title>
        <description><![CDATA[Stories by chanyoung Kwon on Medium]]></description>
        <link>https://medium.com/@rnjscksdud1?source=rss-cfb68566ad84------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*M__WZLhlZ_Dsm3Hy</url>
            <title>Stories by chanyoung Kwon on Medium</title>
            <link>https://medium.com/@rnjscksdud1?source=rss-cfb68566ad84------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 20:42:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rnjscksdud1/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[한글 오타 검색 정확도 개선(OpenSearch)]]></title>
            <link>https://medium.com/@rnjscksdud1/%ED%95%9C%EA%B8%80-%EC%98%A4%ED%83%80-%EA%B2%80%EC%83%89-%EC%A0%95%ED%99%95%EB%8F%84-%EA%B0%9C%EC%84%A0-opensearch-f6e8c8a12766?source=rss-cfb68566ad84------2</link>
            <guid isPermaLink="false">https://medium.com/p/f6e8c8a12766</guid>
            <category><![CDATA[opensearch]]></category>
            <category><![CDATA[korean]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[elasticsearch]]></category>
            <category><![CDATA[spell-check]]></category>
            <dc:creator><![CDATA[chanyoung Kwon]]></dc:creator>
            <pubDate>Sat, 21 Nov 2026 05:36:01 GMT</pubDate>
            <atom:updated>2026-11-21T05:36:01.498Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q_lbRMgVC9WPT_e49M9cwQ.png" /></figure><h3>1. 들어가며</h3><p><a href="https://chanyoung-kwon.notion.site/Suggester-OpenSearch-3-727e5ea23d6b83ff8400015d1d12b871?source=copy_link">기존에 만든 오타 검색</a>을 일주일 동안 서비스를 운영해보고 받은 피드백과 코드를 다시 보며 걸리는 지점을 정리했습니다. 크게 두 가지였습니다.</p><ol><li><strong>띄어쓰기에 따라 교정이 안 된다.</strong> 나무 두감이라고 치면 나무도감을 찾지 못했습니다.</li><li><strong>검색 결과와 추천어가 섞여 있다.</strong> 오타를 추측한 결과가 검색 결과 목록에 같이 올라왔습니다.</li></ol><p>앞서 “무엇을 만들 것인지부터 정의”하고 그 정의에 맞춰 위 두 가지를 리팩터링했습니다. “오타를 고쳐준다”는 말은 너무 넓어서 그대로 두면 어디까지 했을 때 끝난 건지 알 수 없습니다.</p><h4>1.1 무엇을 만들 것인가</h4><p>첫 번째는 <strong>띄어쓰기입니다.</strong> 제가 다루는 카탈로그는 여러 사람이 인수인계를 받아가며 입력한 것이라 표기가 제각각입니다. 실제로 측정해보았습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j7b8950eh_nEfd274n-4Tw.png" /></figure><p>전체 4,147권 중 <strong>공백이 하나도 없는 제목이 2,867건(69.1%)</strong>, 공백이 있는 제목이 1,280건(30.9%)입니다. 같은 성격의 책인데도 놓지마 과학 (1~15)처럼 띄어 쓴 것과 나무도감(세밀화로 그린 큰도감)처럼 붙여 쓴 것이 섞여 있습니다.</p><p>문제는 <strong>사용자가 그 사정을 모른다</strong>는 겁니다. 검색창에 띄어 칠지 붙여 칠지는 그 사람 습관이지, 카탈로그의 표기와는 아무 상관이 없습니다. 그러니 네 가지 조합이 전부 나옵니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QZqzZGn2i8wSQXp27U0IMA.png" /></figure><p><strong>네 칸을 전부 대응해야 합니다.</strong> 세 칸만 되는 기능은 사용자 입장에서 “가끔 안 되는 기능”이고, 왜 안 되는지 설명할 방법도 없습니다. 이 표는 4장에서 사용자 입력에 오타가 없을 때와 있을 때로 나눠 답을 채워 다시 꺼내겠습니다.</p><p>두 번째는 <strong>추천어가 지켜야 할 것</strong> 세 가지입니다.</p><ol><li><strong>누르면 반드시 결과가 나와야 한다.</strong> 그럴듯한 문자열을 만들어 놓고 눌렀더니 0건이면, 오타를 두 번 겪게 하는 셈입니다.</li><li><strong>책 한 권이 아니라 검색어여야 한다.</strong> 기역을 친 사람이 원한 건 기억1이라는 특정 도서가 아니라 기억이라는 <strong>검색어</strong>입니다. 제목을 그대로 제안하면 눌렀을 때 그 책 한 권만 나옵니다.</li><li><strong>내가 친 내용에서 나와야 한다.</strong> 더불어줖을 쳤는데 불패의 리더가 같이 뜨면, 사용자는 그게 왜 떴는지 짐작할 방법이 없습니다.</li></ol><p>이 세 가지를 지키려면 전제가 하나 필요했습니다. <strong>검색 결과와 추천어의 역할이 갈려 있어야 합니다.</strong> 검색 결과는 LIKE &#39;%입력%&#39;처럼 <strong>실재하는 것만</strong> 내놓고, 추측은 전부 추천어로 내보내는 구조입니다.</p><h3>2. nori를 사용하지 않은 이유</h3><p>처음 OpenSearch를 붙일 때는 한글 형태소 분석기 nori를 썼습니다. 한글은 띄어쓰기만으로 단어를 나눌 수 없으니 형태소로 쪼개야 한다는 것이, 한글 검색을 찾아보면 가장 많이 나오는 방법이었기 때문입니다.</p><p>실제 데이터를 넣고 나서 이 검색어에 걸렸습니다.</p><pre>소셜쓰기의모   3건   1위 쓸모인류      (정답: 소설쓰기의모든것)</pre><p>소설을 소셜로 잘못 친 입력입니다. 그런데 결과에 나온 건 쓸모인류였습니다. 쿼리를 절별로 떼어서 각각 돌려봤습니다.</p><pre>형태소 절(multi_match)         3건   쓸모인류, 역사의쓸모      ← 노이즈<br>match_phrase(title.ngram)    0건<br>match(title.ngram, 3&lt;80%)    5건   소설쓰기의모든것1, 2      ← 정답</pre><p><strong>정답을 찾는 절은 따로 있었고, 형태소 절이 엉뚱한 책을 위로 올리고 있었습니다.</strong> 토큰을 찍어보니 이유가 분명했습니다.</p><pre>소셜쓰기의모  →  소셜 (pos 0)<br>              쓰 (pos 1)   쓸 (pos 1)     ← 같은 자리<br>              모 (pos 4)</pre><pre>역사의쓸모    →  역사 (pos 0)<br>              쓸모 (pos 2)  쓸 (pos 2)     ← 같은 자리<br>              모 (pos 3)</pre><p>쓰기를 활용형으로 보고 쓰와 쓸을 같은 position에 깔아놓습니다. 같은 자리의 토큰은 Lucene이 SynonymQuery로 묶어 <strong>절 하나</strong>로 세기 때문에, minimum_should_match: &quot;2&lt;75%&quot;가 요구하는 정족수도 같이 내려갑니다.</p><pre>절 3개 → 75% → 2개만 맞으면 통과</pre><pre>소셜  ❌     Synonym(쓰|쓸)  ✅     모  ✅     →  통과</pre><p>의미를 담은 소셜은 오타라 빠졌는데, <strong>활용형 파편과 한 글자가 정족수를 채웠습니다.</strong> 역사의쓸모도 쓸모에서 같은 파편이 나오니 파편끼리 매칭된 겁니다.</p><p>형태소 절이 오타를 늘 틀리게 잡는 건 아닙니다. 파편이 운 좋게 맞으면 원래 책을 1위로 올려주기도 합니다. 하지만 <strong>그건 검색이 아니라 추측</strong>입니다. 소셜쓰기의모는 어떤 제목에도 부분 문자열로 없습니다. 결과 목록이 3건을 내놓으면 UI는 그걸 “찾았다”고 말합니다. 맞을 때는 소설쓰기의모든것이 나오고 틀릴 때는 쓸모인류가 나오는데, <strong>사용자는 둘을 구분할 방법이 없습니다.</strong></p><p>그래서 1.1의 전제가 여기서 나왔습니다. <strong>추측을 결과 목록에 섞지 않는다.</strong> 형태소 절을 빼면 오타 입력은 결과가 0건이 되고, 그 구간은 전부 추천어가 맡습니다. 추천어는 “혹시 이걸 찾으셨나요?”라고 <strong>추측이라는 걸 드러낸 채로</strong> 내놓으니 틀려도 사용자가 속지 않습니다.</p><p>nori가 틀렸던 게 아닙니다. <strong>한 글자 ngram과 역할이 겹쳤고</strong>, 붙여쓰기가 69%인 도서 제목에서는 형태소 경계 자체가 신뢰할 수 있는 단위가 아니었습니다. 검색에서 형태소 필드를 안 보게 되자 korean_nori를 참조하는 곳이 한 군데도 없어서 원본 필드의 역색인을 아예 내렸습니다.</p><pre>&quot;title&quot;:  { &quot;type&quot;: &quot;text&quot;,<br>-             &quot;analyzer&quot;: &quot;korean_nori&quot;,<br>+             &quot;index&quot;: false,<br>              &quot;fields&quot;: { … } }</pre><h3>3. 리팩터링</h3><p>검색은 title.ngram, author.ngram 두 절만 남았습니다. 한 글자 ngram에 match_phrase를 걸면 위치가 연속인 것만 걸리므로, 의미가 정확히 LIKE &#39;%입력%&#39;입니다. 공백은 token_chars: [&quot;letter&quot;,&quot;digit&quot;] 때문에 애초에 토큰이 되지 않아서, <strong>오타만 없다면 띄어쓰기 차이는 검색 단계에서 이미 무의미합니다.</strong></p><pre>&#39;놓지마 과학&#39;  →  title.ngram  [놓(0) 지(1) 마(2) 과(3) 학(4)]<br>                                        ↑ 공백 자리가 비지 않는다<br>&quot;놓지마과학&quot; 로 쳐도 match_phrase 가 매치된다</pre><p>남은 건 <strong>오타가 섞였을 때</strong> 무엇을 제안하느냐입니다. 여기서부터가 이 글의 본론입니다.</p><h4>3.1 왜 자모로 쪼개는가</h4><p>OpenSearch의 phrase suggester를 그대로 붙이면 이런 일이 생깁니다.</p><pre>&quot;기역&quot;  →  기술</pre><p>정답은 기억인데 기술이 나옵니다. 제목에 등장하는 횟수를 세어보면 이유가 보입니다.</p><pre>&#39;기술&#39; 포함 제목  53건<br>&#39;기적&#39; 포함 제목  24건<br>&#39;기억&#39; 포함 제목  14건<br>&#39;기록&#39; 포함 제목   5건</pre><p><strong>suggester는 빈도로 점수를 매기는데, 오타 교정에 필요한 건 닮음입니다.</strong> 둘이 어긋나면 흔한 단어가 이깁니다.</p><p>닮음으로 고르려 해도 음절 단위로는 고를 수가 없습니다. 기술, 기적, 기억, 기록 모두 기역과 음절 하나가 다르니, <strong>음절로 재면 후보가 전부 거리 1</strong>입니다. 한글 음절 하나에 초성, 중성, 종성 셋이 들어 있는데, 음절로 재면 <strong>셋 중 하나가 틀린 것과 셋 다 틀린 것이 똑같이 “한 글자 차이”</strong>가 됩니다.</p><p>자모로 내려가면 갈립니다.</p><pre>기역 → ㄱㅣㅇㅕㄱ<br>기억 → ㄱㅣㅇㅓㄱ   거리 1   ← 채택<br>기술 → ㄱㅣㅅㅜㄹ   거리 3</pre><p>사전 자체를 자모로 색인하기로 했습니다.</p><h4>3.2 어떤 자모인가: 글자표가 두 벌입니다</h4><p>“자모로 분해한다”고 하면 하나인 것 같지만 표가 두 벌입니다.</p><pre>&#39;각&#39;<br>   조합용 자모 (NFD)   U+1100 U+1161 U+11A8      ᄀ ᅡ ᆨ<br>   호환용 자모         U+3131 U+314F U+3131      ㄱ ㅏ ㄱ</pre><p>이 차이가 <strong>편집거리에 그대로 나타납니다.</strong> 어느 표를 고를지는 어떤 오타를 잡을 것이냐에 달려 있었습니다. 오타를 종류별로 나눠 두 표에서 거리를 재보면 갈립니다.</p><ul><li><strong>자모 치환</strong>(소설 → 소셜)은 두 표가 똑같습니다. 초성은 초성으로, 중성은 중성으로 바뀌어 자리 종류가 유지되니까요.</li><li><strong>키 입력 누락</strong>과 <strong>연음 오타</strong>는 서로 반대쪽이 짧게 나옵니다.</li></ul><pre>키 입력 누락   음악을 → 으악을     조합용이 짧다   (내가 안 누른 키 하나 = 자모 하나)<br>연음 오타     새들이 → 새드리     호환용이 짧다   (호환 1 / ICU 2)<br>            음양감식 → 으먕감식   호환용이 짧다   (호환 1 / ICU 2)</pre><p>연음 오타에서 호환용이 유리한 건 초성 ㅁ과 종성 ㅁ이 같은 문자라 음절 경계가 밀려도 맞아떨어지기 때문입니다. 반대로 키를 하나 빠뜨린 경우는 조합용이 유리합니다.</p><p><strong>우리가 잡아야 할 건 타자 오타입니다.</strong> 연음은 “들은 대로 적은” 경우라 오타라기보다 다른 표기에 가깝고 잡으려면 발음 규칙을 따로 모델링해야 합니다. 그래서 <strong>조합용(ICU)을 골랐습니다.</strong></p><p>색인 시점 분해는 analysis-icu 플러그인이 해줍니다.</p><pre>// src/main/resources/opensearch/books_index.json<br>&quot;char_filter&quot;: {<br>  &quot;hangul_jamo&quot;: { &quot;type&quot;: &quot;icu_normalizer&quot;, &quot;name&quot;: &quot;nfc&quot;, &quot;mode&quot;: &quot;decompose&quot;}<br>}</pre><p>name이 정규화 <strong>계열</strong>을 고르고 mode가 <strong>방향</strong>을 고릅니다. nfc + decompose가 실질적으로 NFD입니다.</p><p>여기에 덤이 하나 있습니다. 검색어를 푸는 건 애플리케이션 몫인데(분석기는 색인할 때만 도니까요), 조합용 자모는 초성과 종성이 다른 코드포인트라 <strong>합성할 때 모호함이 없습니다.</strong></p><pre>&#39;나무&#39; → ᄂ ᅡ ᄆ ᅮ        ← ᄆ 은 초성 (U+1106)<br>&#39;남우&#39; → ᄂ ᅡ ᆷ ᄋ ᅮ      ← ᆷ 은 종성 (U+11B7)</pre><p>호환용이었다면 ㄴㅏㅁㅜ의 ㅁ이 종성인지 다음 음절 초성인지 <strong>한 칸 앞을 봐야</strong> 알 수 있어서 규칙을 직접 짜야 합니다. 조합용에서는 그럴 필요가 없어서 앱 코드가 JDK 표준 호출 두 줄로 끝납니다.</p><pre>// src/main/kotlin/org/library/external/opensearch/index/HangulJamo.kt<br>object HangulJamo {<br>    fun decompose(text: String): String = Normalizer.normalize(text, Normalizer.Form.NFD)<br>    fun compose(jamo: String): String = Normalizer.normalize(jamo, Normalizer.Form.NFC)<br>}</pre><h4>3.3 사전과 채점표를 나눈 이유</h4><pre>direct_generator.field   &quot;이 문자열이 존재하는가&quot;    ← 사전<br>phrase.field             &quot;이 조합이 그럴듯한가&quot;      ← 채점표</pre><p>사전은 용어 하나하나를 퍼지 오토마타로 훑어 <strong>후보를 만드는</strong> 데 쓰고 채점표는 만들어진 후보들을 n-gram 확률로 <strong>줄 세우는</strong> 데 씁니다. 역할이 다르니 분석기도 달라야 합니다.</p><pre>&quot;jamo_word&quot;:    { char_filter: [hangul_jamo], tokenizer: standard,<br>                  filter: [lowercase, unspaced_shingle] } → title.jamo (사전)<br>&quot;jamo_trigram&quot;: { char_filter: [hangul_jamo], tokenizer: standard,<br>                  filter: [lowercase, spaced_shingle] }   → title.jamo_trigram(채점표)</pre><p>여기서 1.1의 4분면 중 <strong>한 칸만 구멍</strong>이었습니다. 놓지마 과학이라는 책을 놓지마과학이라고 붙여서 치는 경우입니다. 사전은 standard 토크나이저를 써서 어절별로만 색인됩니다.</p><pre>&quot;노치마 과학&quot;  →  토큰 2개  [노치마][과학]   →  단어별로 교정 → &#39;놓지마 과학&#39;  ✅<br>&quot;노치마과학&quot;   →  토큰 1개  [노치마과학]     →  사전에 그런 term 이 없다      ❌</pre><p>붙인 형태를 사전에 넣는 건 shingle 필터 한 줄입니다. token_separator를 빈 문자열로 주면 인접 어절을 공백 없이 이어 붙인 term이 같이 생깁니다.</p><pre>&quot;unspaced_shingle&quot;: { &quot;type&quot;: &quot;shingle&quot;, &quot;min_shingle_size&quot;: 2, &quot;max_shingle_size&quot;: 2,<br>                   &quot;token_separator&quot;: &quot;&quot;, &quot;output_unigrams&quot;: true }</pre><pre>title.jamo          &#39;놓지마 과학&#39;  →  [놓지마, 놓지마과학, 과학]    ← unspaced_shingle 이 가운데를 만든다<br>title.jamo_trigram  &#39;놓지마 과학&#39;  →  [놓지마, 놓지마 과학, 과학]   ← spaced_shingle</pre><p><strong>하지만 채점표에는 넣지 않았습니다.</strong> 이유는 두 가지입니다.</p><p>첫째, shingle 필터는 쌓을 수 없습니다. unspaced_shingle 뒤에 spaced_shingle을 이어 붙이면 두 번째 shingle이 첫 번째 결과까지 재료로 삼습니다.</p><pre>&#39;놓지마 과학 이야기&#39; 에 shingle 두 개를 쌓으면<br>   놓지마, 놓지마 놓지마과학, 놓지마 놓지마과학 과학, 놓지마과학 과학 과학이야기, …<br>                ↑ 쓸모없는 항이 생기고, 정작 &#39;놓지마 과학 이야기&#39; 가 사라진다</pre><p>둘째, 그렇다고 채점표의 구분자만 빈 문자열로 바꾸면 <strong>어절 조합을 구분하는 능력이 죽습니다.</strong> &quot;노치마 과학&quot;의 후보 점수를 직접 봤습니다.</p><pre>공백 n-gram (현재)            붙인 n-gram 으로 바꾸면<br>   놓지마 과학  0.012269510      0.000151085<br>   놓지마 개혁  0.000120444      0.000147579<br>              ↑ 102배 차이        ↑ 1.02배 → 사실상 동점</pre><p>채점표가 놓지마 과학이라는 <strong>연결</strong>을 알고 있어야 놓지마 개혁 같은 후보를 밀어낼 수 있습니다. 붙여버리면 그 연결 정보가 사라집니다. 그래서 <strong>사전에는 붙인 형태를 넣고, 채점표는 띄운 채로 둡니다.</strong></p><p>이 선택이 무엇을 바꾸는지는 노치마과학 하나로 보입니다. 사전에 붙인 term이 없으면 suggester가 후보를 못 만들어 뒤에 나올 폴백 경로로 내려가는데, 폴백은 글자 겹침만 보기 때문에 철학과마음 같은 책을 같이 물어다 줍니다. 붙인 term이 있으면 suggester가 직접 <strong>놓지마 과학</strong> 하나를 답합니다. 대가로 인덱스는 928kb에서 1,017kb로 늘었습니다.</p><h4>3.4 confidence를 0.9로 둔 이유</h4><p>unspaced_shingle을 넣고 나서 바로 걸린 게 confidence였습니다. 기본값 1.0으로 두면 <strong>붙인 후보가 하나도 안 나옵니다.</strong></p><p>confidence는 절대 점수가 아니라 <strong>원문 대비 배율</strong>입니다. suggester는 후보를 채점한 뒤 검색어 원문도 같은 방식으로 채점하고, 원문 점수 × confidence를 넘는 후보만 남깁니다. 후보를 더 만들지도 점수를 바꾸지도 않고, <strong>채점이 끝난 목록을 자르는 가위</strong> 역할만 합니다.</p><pre>&quot;노치마과학&quot; 의 후보<br>   노치마과학  0.010828468   ← 원문 자신<br>   놓지마과학  0.010148286   ← 정답. 원문의 0.937배</pre><p>정답이 원문보다 <strong>낮습니다.</strong> unspaced_shingle이 만든 term은 채점표(title.jamo_trigram)에 있을 수가 없으니(채점표는 공백으로 잇습니다) 백오프 바닥값을 받는데, 원문도 인덱스에 없어서 같은 바닥값을 받기 때문입니다. confidence: 1.0은 “원문보다 <strong>엄격히</strong> 높을 것”이라 여기서 탈락합니다.</p><p>원문과 정답이 <strong>같은 바닥값에서 출발하니, 정답은 원문과 거의 같은 점수</strong>를 받습니다. 그래서 confidence는 연속적인 손잡이라기보다 <strong>사실상 스위치</strong>입니다. 1.0이면 원문보다 조금이라도 낮은 정답이 잘리고, 그보다 낮추면 통과합니다.</p><p>그러면 0.0(문턱 없음)으로 두면 될까요? 그렇게 하면 원문보다 한참 낮은, 명백히 나쁜 후보까지 전부 앱으로 넘어옵니다. 뒤에 나오는 findContainingTitle이 후보마다 OpenSearch를 한 번씩 더 왕복하기 때문에, 나쁜 후보는 일찍 떨어뜨리는 게 이득입니다. 그래서 <strong>원문 근처의 정답은 살리고 멀리 떨어진 후보는 자르는 0.9</strong>로 뒀습니다.</p><p>문턱이 원문 아래로 내려가면 <strong>원문 자신도 통과</strong>합니다. 편집거리로 고르는 이상 거리 0인 원문이 무조건 1등이 되니, 애플리케이션에서 걷어냅니다.</p><pre>// src/main/kotlin/org/library/book/adapter/OpenSearchBookSearchAdapter.kt<br>val typed = asNgramText(keyword)<br>val options = root.path(&quot;suggest&quot;).path(BookIndex.TITLE_SUGGEST_NAME).path(0).path(&quot;options&quot;)<br>    .mapNotNull { … }<br>    .filter { asNgramText(HangulJamo.compose(it.text)) != typed }   // 원문 제거</pre><p>한 가지는 남겨둡니다. <strong>노치마과학의 정답이 원문의 0.937배라, 0.9와의 간격이 넓지 않습니다.</strong> 책이 크게 늘어 점수 분포가 움직이면 정답이 조용히 잘릴 수 있어서, 데이터가 바뀌면 3.6의 평가 도구로 다시 확인해야 하는 숫자입니다.</p><h4>3.5 애플리케이션이 하는 일</h4><p>OpenSearch가 주는 건 “자모 문자열 후보 목록”까지입니다. 그걸 <strong>사용자가 누를 수 있는 검색어</strong>로 바꾸는 건 전부 애플리케이션 몫입니다.</p><pre>1차 요청  query   match_phrase title.ngram ^2  +  match_phrase author.ngram ^1<br>          suggest title_suggest (confidence 0.9)</pre><pre>  hits.total &gt; 0  →  suggestions = []            정상 검색은 왕복 한 번으로 끝<br>  hits.total = 0  →  추천 조립 시작<br>      ① selectJamoCandidates      원문 제거 → 점수 하한 → 자모 편집거리 정렬 → 음절 합성<br>      ② retryUnspaced             검색어에 공백이 있을 때만 공백을 빼고 한 번 더<br>      ③ findContainingTitle       실재하는 제목인지 확인한다 (점수 1위 한 건)<br>      ④ toSearchWord              제안어 자리에서 입력 길이만큼 자른다<br>      ⑤ unorderedNgramCandidates  ①이 빈손일 때만: 순서를 푼 조회</pre><p>결과 쿼리에는 부분 문자열 절만 남았으니, <strong>결과가 한 건이라도 나오면 그 검색어는 데이터에 실재합니다.</strong> 그러면 고칠 것이 없습니다.</p><p><strong>3.5.1 편집거리로 다시 세운다.</strong></p><p>suggester의 점수는 빈도라 순위를 믿을 수 없습니다(3.1). 최고점의 50% 이상인 후보만 남기고 자모 편집거리로 다시 정렬합니다. 그 아래로 내리면 언어모델을 사실상 무시하게 되므로 하한은 50%로 뒀습니다.</p><pre>val scoreFloor = (options.maxOfOrNull { it.score } ?: return emptyList()) * SUGGEST_SCORE_FLOOR_RATIO<br>return options.filter { it.score &gt;= scoreFloor }<br>    .sortedWith(compareBy({ editDistance(jamoText, it.text) }, { -it.score }))<br>    .map { Candidate(HangulJamo.compose(it.text), it.score) }</pre><p>정렬이 끝난 <strong>뒤에</strong> 음절로 합칩니다. 거리는 자모 상태에서 재야 기억(1)과 기술(3)이 갈리니까요.</p><p><strong>3.5.2 공백을 빼고 한 번 더 묻는다.</strong></p><p>4분면의 나머지 한 칸(붙여 쓴 제목을 띄어서 치는 경우)입니다. 제목이 통짜라 띄어서 친 검색어는 어절별로 쪼개져 비교 대상이 어긋납니다.</p><pre>&quot;나무 도감&quot;   0.000306<br>&quot;나무도감&quot;    0.016953   ← 55배</pre><p>공백이 있을 때만 나가고, 점수가 더 높은 쪽으로 목록을 통째로 교체합니다.</p><p><strong>3.5.3 실재하는 제목으로 되돌린다.</strong></p><p>후보는 자모를 합친 문자열일 뿐이라 실제로 그런 책이 있는지는 별개입니다. match_phrase로 조회해서 걸리지 않으면 버립니다. 이게 1.1의 첫 번째 요건(누르면 결과가 나와야 한다)을 보장합니다.</p><p>match_phrase는 부분 문자열이라 더 긴 제목이 같이 걸리고, BM25는 짧은 필드에 높은 점수를 줍니다.</p><pre>findContainingTitle(&quot;나무도감&quot;)<br>   13.9  중국대나무도감                    ← 점수 1위<br>   10.8  나무도감(세밀화로 그린 큰도감)<br>   10.8  나무도감(세밀화로 그린 어린이)</pre><p>나무도감이라는 책이 실제로 있는데도 제목이 짧다는 이유로 중국대나무도감이 1위입니다. 처음엔 이게 문제처럼 보였는데, <strong>어느 제목을 고르든 결과는 같습니다.</strong> 다음 단계(④)는 제목 전체를 쓰지 않고 <strong>제안어가 있는 자리에서 입력 길이만큼만</strong> 잘라냅니다. 중국대나무도감에서도 나무도감 자리를 찾아 자르니 결과는 나무도감입니다.</p><p>여러 건을 받아 고를 필요가 없으니 <strong>점수 1위 한 건만 받습니다.</strong> 이 조회는 <strong>실재하는지 확인</strong>하는 일만 맡습니다.</p><p><strong>3.5.4 제목이 아니라 검색어로 자른다.</strong></p><p>1.1의 두 번째 요건입니다. 제목을 그대로 제안하면 눌렀을 때 그 책 한 권만 나옵니다.</p><pre>&quot;기역&quot;       →  기억1 → 2글자                →  &#39;기억&#39;       →  14건<br>&quot;아투인문학&quot;   →  아트인문학여행(스페인) → 5글자   →  &#39;아트인문학&#39;   →  3건</pre><p>시리즈물이 접두사에서 저절로 합쳐지는 건 덤입니다. 다만 <strong>맨 앞에서 자르면 안 됩니다.</strong> ③이 부분 문자열로 찾기 때문에 제안어가 제목 한가운데 있을 수 있습니다.</p><pre>아투인  →  후보 &#39;우주인&#39;<br>      →  제목 &#39;열한번째 도끼질 : 대한민국 최초 우주인 이소연의 …&#39;<br>      →  앞에서 3글자                    →  &#39;열한번&#39;   ✗<br>      →  &#39;우주인&#39; 이 있는 자리에서 3글자    →  &#39;우주인&#39;   ✓</pre><p>기준점은 <strong>제안어가 시작하는 자리</strong>로 잡습니다. 위치를 찾는 데는 손이 한 번 더 갑니다. 제안어는 색인 term이라 소문자에 문장부호가 없는데, 제목 원문은 그렇지 않습니다. 글자, 숫자만 남긴 사본에서 위치를 찾아 원문 인덱스로 되돌리면 표기까지 살아납니다(wto체재 → <strong>WTO체제</strong>).</p><pre>private fun toSearchWord(title: String, anchor: String?, length: Int): String {<br>    val positions = ArrayList&lt;Int&gt;(title.length)<br>    val flat = buildString {<br>        title.forEachIndexed { at, char -&gt;<br>            if (char.isLetterOrDigit()) { append(char.lowercaseChar()); positions += at }<br>        }<br>    }<br>    if (positions.isEmpty() || length &lt;= 0) return title<br>    val start = anchor?.let { flat.indexOf(asNgramText(it)) }?.takeIf { it &gt;= 0 } ?: 0<br>    val last = start + length - 1<br>    return if (last &gt;= positions.size) title.substring(positions[start])<br>           else title.substring(positions[start], positions[last] + 1)<br>}</pre><p>자른 문자열은 어느 쪽이든 후보 제목의 부분 문자열이라 <strong>그 제목에 반드시 걸립니다.</strong> 제안을 눌렀는데 0건이 나오는 일이 구조적으로 없습니다.</p><p><strong>3.5.5 suggester가 빈손일 때만 내려가는 폴백.</strong></p><p>자모는 치환에 강하지만 생략에는 약합니다. 자모 단위로 세면 안 친 글자가 3배가 됩니다.</p><pre>아투인문학 vs 아트인문학여행<br>   음절 거리 3   /   자모 거리 6   ← max_edits: 2 에서 더 멀어진다</pre><p>제목을 끝까지 치지 않는 건 흔한 습관이라 이 구간을 버릴 수 없었습니다. 순서를 푼 조회(minimum_should_match: &quot;3&lt;80%&quot;)를 폴백으로 둡니다. 글자가 겹치는 정도만 보므로 suggester가 후보조차 못 만드는 구간을 덮습니다.</p><p><strong>다만 두 경로를 섞지 않습니다.</strong> 1.1의 세 번째 요건 때문입니다. 순서를 푼 조회는 글자 겹침만 보기 때문에, 1위가 정답이면 2, 3위는 필연적으로 무관한 책이 됩니다.</p><pre>&quot;더불어줖&quot; → 순서 없는 조회<br>   더불어숲                              14.51   ← 정답<br>   불패의 리더 이순신, 그는 어떻게 이겼을까     8.32   ← &#39;더&#39;, &#39;불&#39;, &#39;어&#39; 가 흩어져 있을 뿐<br>   보완대체의학-현대의학과더불어21세기통합의학    6.76   ← 중간에 &#39;더불어&#39; 가 있을 뿐</pre><p>1번 칸을 suggester로 채우고 남는 칸을 이걸로 메우면 <strong>정답 옆에 반드시 쓰레기가 붙습니다.</strong> suggester가 이미 정답을 냈다면 뒤 칸이 정답을 더 건질 일은 없고, 무관한 제안만 늘어납니다.</p><pre>return corrected.ifEmpty { unorderedNgramCandidates(keyword)... }<br>//              ↑ 섞지 않는다. ① 이 답했으면 그것만 쓴다</pre><p><strong>후보가 하나뿐이면 한 칸만 내보냅니다.</strong> suggester가 하나만 찾았다면 그만큼 확실한 경우인데, 거기에 억지로 세 칸을 채우려던 게 노이즈의 출처였습니다.</p><h4>3.6 검증</h4><p>검증 데이터는 <strong>실제로 사용하는 컴퓨터의 검색 기록</strong>에서 가져왔습니다. OpenSearch의 Query Insights는 5분마다 비용이 큰 쿼리 상위 10개를 top_queries-* 인덱스에 남기는데, 사용량이 적어 이 기록이 사실상 전체 검색을 담고 있다고 보고, 여기서 앱이 보낸 검색어 335개를 뽑아 두 묶음으로 나눴습니다.</p><ul><li><strong>오타 검색어 37개</strong>: 결과가 0건이었던 검색어 중 <strong>두 번 이상 들어왔고 의도한 책이 분명한 오타</strong>입니다. 각각에 의도한 책의 bookId를 정답으로 달았습니다. 입력 도중의 조각(아ㅌ, 강원ㄱ)이나 의미 없는 입력은 뺐습니다.</li><li><strong>정상 검색어 161개</strong>: 결과가 있었던 검색어 전부입니다.</li></ul><p>이걸 골든셋 파일로 만들고, <strong>실제 </strong><strong>OpenSearchBookSearchAdapter를 그대로 호출하는</strong> 평가 도구를 devtools에 두었습니다. 판정 기준은 추천어 문자열이 맞는지가 아니라 <strong>그 추천어를 눌렀을 때 의도한 책이 나오는가</strong>입니다. 제안이 제목에서 검색어로 바뀌었으니 기준도 따라 바뀌어야 합니다.</p><pre>src/devtools/resources/benchmark/typo-golden-set.tsv                            ← 골든셋<br>src/devtools/kotlin/org/library/devtools/benchmark/TypoSuggestionEvaluator.kt   ← 평가 도구</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9g75yi4JHMYIhLRqkkyOsQ.png" /></figure><p>오타 검색어는 결과 목록에 아무것도 올리지 않고(0건), 정상 검색어에는 추천이 하나도 붙지 않습니다. <strong>결과와 추측이 깨끗하게 갈려 있습니다.</strong> 오탐 0건은 우연이 아니라 구조가 보장합니다. 결과가 한 건이라도 있으면 추천 조립 자체를 시작하지 않으니까요.</p><p>무관한 제안 5칸은 쉽게찿는우리나무1 옆의 쉽게찾는우리나무2, 3(같은 시리즈의 다른 권), 기역 옆의 기적, 기록, 강원긱의 옆의 강파워포입니다. 1순위가 정답이라 사용자가 헤맬 일은 없지만, 뒤 칸은 여전히 닮은 다른 검색어입니다.</p><p>케이스별로 보면 이렇습니다(로그에 자주 나온 순).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HQPug8kJiYjHEoJgor4UXg.png" /></figure><p>노치마 과학과 노치마과학이 <strong>같은 답을 내놓고</strong>, 붙여 쓴 책 나무도감을 띄어 친 나무 두감도 잡힙니다. 4분면이 닫혔습니다. 어순을 바꿔 친 한반도를사막화하고있다 북한산림은 suggester가 아니라 ⑤ 폴백이 받았습니다.</p><p>평가 도구는 레포에 있으니 인덱스나 파라미터를 바꿀 때마다 다시 돌려 이 표가 유지되는지 확인합니다. 색인은 4,147건에 <strong>1,017kb</strong>입니다.</p><h3>4. 정리</h3><p>1.1에서 비워둔 표를 채우면, 사용자 입력에 <strong>오타가 있느냐 없느냐</strong>에 따라 두 장이 됩니다. 책 제목은 두 경우 모두 카탈로그에 저장된 그대로이고, 띄어 쓴 것(놓지마 과학 (1~15))과 붙여 쓴 것(나무도감(세밀화로 그린 큰도감))이 섞여 있을 뿐입니다.</p><p><strong>오타가 없을 때</strong>: 네 칸 모두 검색이 바로 찾습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CdIXUlOpyYXcwDmxjhALSA.png" /></figure><p>title.ngram은 공백을 토큰으로 만들지 않아서, 띄어 치든 붙여 치든 글자의 위치가 똑같이 이어집니다. 그래서 1차 요청의 match_phrase가 네 칸을 전부 받고, 결과가 있으니 추천 조립은 시작하지도 않습니다. <strong>오타가 없으면 띄어쓰기는 문제가 아니었습니다.</strong></p><p><strong>오타가 있을 때</strong>: 검색은 네 칸 모두 0건이고, 칸마다 다른 장치가 추천어를 만듭니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1BciEdaZUcPERCJ1J0PP_w.png" /></figure><p>대각선 두 칸(책과 입력의 모양이 같은 경우)은 기본 동작만으로 되고, 모양이 엇갈린 두 칸에 장치가 하나씩 필요했습니다. 띄어 친 입력은 <strong>입력 쪽을 붙여서</strong>(retryUnspaced), 붙여 친 입력은 <strong>사전 쪽을 붙여서</strong>(unspaced_shingle) 맞춥니다. 붙여 친 입력의 추천어가 놓지마과학이 아니라 놓지마 과학으로 나오는 건, toSearchWord가 실제 제목에서 잘라내면서 원문의 띄어쓰기를 그대로 가져오기 때문입니다.</p><p>suggester가 어느 칸에서든 후보를 하나도 못 만들면(초성 오타, 생략이 많은 입력) 순서를 푼 조회로 내려가는데, 이 조회는 title.ngram의 글자 겹침만 보므로 띄어쓰기와 상관없이 네 칸에 똑같이 적용됩니다.</p><p>추천어의 요건 세 가지는 이렇게 보장됩니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gs1Mm4tiRAfmZ5YDrJ8PLw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f6e8c8a12766" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[자연어로 요청하는 QA 시스템 만들기]]></title>
            <link>https://medium.com/@rnjscksdud1/%EC%9E%90%EC%97%B0%EC%96%B4%EB%A1%9C-%EC%9A%94%EC%B2%AD%ED%95%98%EB%8A%94-qa-%EC%8B%9C%EC%8A%A4%ED%85%9C-%EB%A7%8C%EB%93%A4%EA%B8%B0-26a5ca095964?source=rss-cfb68566ad84------2</link>
            <guid isPermaLink="false">https://medium.com/p/26a5ca095964</guid>
            <category><![CDATA[playwright-test]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[qa]]></category>
            <dc:creator><![CDATA[chanyoung Kwon]]></dc:creator>
            <pubDate>Fri, 20 Nov 2026 19:26:01 GMT</pubDate>
            <atom:updated>2026-11-20T19:26:01.697Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lY8sdwmEv_A1pLllPimbNA.png" /><figcaption>아키텍처</figcaption></figure><h3>1. 들어가며</h3><p>도서관 관리 시스템은 개인 프로젝트로 백엔드는 직접 작성하고 프론트엔드는 Claude Design으로 만든 디자인을 AI 하네스가 Next.js 코드로 구현합니다.</p><p>하지만 AI로 빨라진 만큼 “이 화면이 정말 의도대로 동작하는가”를 확인하는 시간이 늘었습니다. 프로젝트에 자동 테스트는 0건이었고 하네스의 QA 단계는 타입 체크, 빌드, 린트만 돌렸습니다.</p><p>그러던 중 토스 프론트엔드 팀의 발표를 봤습니다. (<a href="https://www.youtube.com/watch?v=YCNcTpcDRf8&amp;start=2">https://www.youtube.com/watch?v=YCNcTpcDRf8&amp;start=2</a>) AI로 개발 속도가 몇 배 빨라졌지만 AI가 만든 결과물을 검증하고 신뢰하는 데 걸리는 시간이 새로운 병목이 됐다는 내용이었습니다. 처음에는 코드와 기획 문서에서 테스트를 자동 생성하려 했지만 코드에는 모든 디테일이 있어도 <strong>“무엇이 중요한 검증 포인트인가”라는 사람의 의도</strong>가 없어서 실패했다고 합니다. 결국 실무자가 직접 요청하거나 조작한 행동을 바탕으로 테스트를 만드는 쪽으로 방향을 틀었습니다.</p><p>해당 프로젝트를 개발하는 환경에서도 크게 다르지 않다고 생각하였습니다. QA 요청도 개발자보다 관련 실무자에게서 더 많이 들어왔습니다. <strong>만드는 쪽과 검증하는 쪽을 분리</strong>해야 했고 검증 기준은 코드가 아니라 사람의 의도에서 와야 했습니다.</p><p>목표는 이렇게 정했습니다.</p><blockquote><em>코드를 모르는 사람(기획자, 실제 사용자인 사서)도 Slack에 </em><strong><em>“반납하면 대출자 이름이 사라지는지 확인해줘”</em></strong><em> 라고 말로 요청하면, 시스템이 실제 브라우저로 화면을 검증하고 </em><strong><em>스크린샷과 근거 문서를 붙여</em></strong><em> 답한다.</em></blockquote><h3>2. 선정 스택</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8sq3tm6c5pB1q82kJ1aNbQ.png" /></figure><h4>2.1 n8n: 채널은 바깥에, 로직은 안에</h4><p>n8n은 Slack 입구와 출구만 맡습니다. 입구는 @Library QA 멘션을 받아 멘션 태그만 떼고 QA API로 넘깁니다. 출구는 결과 웹훅을 받아 스레드에 답글과 스크린샷을 올립니다. 메시지 문구와 첨부 목록은 모두 QA 서비스가 만들고 n8n은 전달만 합니다.</p><p>나중에 PR 이벤트나 다른 채널을 붙일 때도 n8n 워크플로 하나만 추가하면 됩니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ur8cVVIu3I4hR-kJklq8JA.png" /><figcaption>외부 서비스에 접속 키 등록</figcaption></figure><h4>2.2 ngrok: 로컬 n8n에 공개 주소 하나만</h4><p>QA 서비스와 n8n은 로컬 머신에서 돌지만 Slack은 인터넷에서 접근 가능한 주소로만 이벤트를 보냅니다. 서버를 따로 두지 않고 ngrok 터널로 로컬 n8n에 공개 주소를 붙였습니다.</p><p>ngrok 컨테이너는 실행될 때 authtoken으로 ngrok 서버에 접속해 도메인을 등록하고 그 연결을 끊지 않고 유지합니다. 이후 요청이 오면 ngrok 컨테이너를 통해 로컬에 요청을 전달합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5u7mw46tH9HmrWJ2QDih3Q.png" /><figcaption>ngrok 도메인 등록</figcaption></figure><h4>2.3 Redis: 큐, 락, 그리고 벡터 인덱스</h4><p>Slack은 이벤트에 3초 안에 응답해야 하는데 검증은 빌드와 브라우저 조작까지 수십 초에서 수 분이 걸립니다. 접수(POST /jobs → 202)와 실행(RQ 워커)은 따로 뗐습니다.</p><p>Redis는 RAG 벡터 인덱스로도 사용했습니다. 자세한 내용은 2.6절에서 설명하겠습니다.</p><h4>2.4 Claude Code + Playwright MCP: AI가 브라우저를 직접 띄운다</h4><p>AI 호출은 Anthropic API가 아니라 Claude Code CLI를 헤드리스로 실행합니다. 현재 사용량이 많지 않고 사용중인 구독 요금제로 진행하고 싶어서 Claude Code를 사용하였습니다.</p><pre>cmd = [<br>    &quot;claude&quot;, &quot;-p&quot;, prompt,<br>    &quot;--output-format&quot;, &quot;json&quot;,<br>    &quot;--json-schema&quot;, json.dumps(schema, ensure_ascii=False),<br>    &quot;--system-prompt&quot;, system,<br>    &quot;--tools&quot;, tools,<br>    # 개발자 환경(훅, MCP, 스킬, CLAUDE.md)이 검증 판단에 섞이지 않도록 격리한다.<br>    &quot;--setting-sources&quot;, &quot;&quot;, &quot;--strict-mcp-config&quot;,<br>    &quot;--no-session-persistence&quot;, &quot;--disable-slash-commands&quot;,<br>]</pre><p>격리 플래그를 켠 데는 이유가 있습니다. 같은 머신에 프론트를 <strong>만드는</strong> 하네스 설정(CLAUDE.md, 스킬, 훅)이 있습니다. 이게 검증하는 Claude에 섞이면 분리한 의미가 사라집니다.</p><p>브라우저 조작은 Playwright MCP가 맡습니다. 픽셀 좌표 대신 <strong>접근성 스냅샷</strong>(버튼, 입력칸, 표의 role과 이름)으로 화면을 읽고 조작합니다. 사람이 화면을 보는 방식과 가깝고 결과도 텍스트로 확인됩니다. 캡처 크기는 시나리오 테스트와 같은 1440×900으로 고정해서 두 방식의 스크린샷을 나란히 비교할 수 있게 했습니다.</p><h4>2.5 pytest-playwright: 결정적 시나리오 테스트</h4><p>AI 탐색은 처음 보는 요청도 검증할 수 있지만 느리고 실행할 때마다 판단이 조금씩 다릅니다. 자주 확인하는 흐름(대출/반납, 검색, 연체 필터 등)은 pytest-playwright로 작성한 <strong>시나리오 테스트</strong>로 돌립니다.</p><p>AI 탐색은 처음 보는 요청도 검증할 수 있지만 느리고 실행할 때마다 판단이 조금씩 다릅니다. 자주 확인하는 흐름(대출/반납, 검색, 연체 필터 등)은 개발자가 pytest-playwright로 미리 작성해 둔 <strong>시나리오 테스트</strong>로 돌립니다. 시나리오의 경우 자주 사용하는 테스트를 함수로 등록합니다.</p><h4>2.6 Obsidian + RAG: 판정 기준은 문서에서</h4><p>“반납하면 대출자 이름이 사라져야 한다”는 기대 동작은 코드에 없습니다. 기획서와 과거 결정에 있습니다. 판정 근거는 Obsidian에 마크다운으로 모았습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G-iyaUR0pyMHKpIdcHPVDw.png" /></figure><p>git으로 관리하는 <strong>원본</strong>이고 검색 인덱스는 언제든 다시 만들 수 있는 <strong>파생물</strong>입니다. 사람이 Obsidian에서 직접 읽고 고칠 수 있고 위키링크로 QA 리포트와 근거 문서의 연결이 그래프로 보입니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E3u5B6mjghC0OdYvBbfUcg.png" /><figcaption>Obsidian 그래프 뷰</figcaption></figure><p>검색은 RAG로 합니다. 노트를 ## 단위로 잘라(최대 1,200자) 다국어 임베딩 모델 multilingual-e5-large로 로컬에서 임베딩해 Redis 벡터 인덱스(HNSW)에 넣습니다. QA 리포트가 계속 쌓이므로 파일 해시가 바뀐 노트만 다시 임베딩합니다.</p><h3>3. 개발 과정</h3><h4>3.1 풀스택 E2E 하나를 결정적으로</h4><p>먼저 프론트만 띄우고 API를 모킹하는 대신 백엔드, DB, 검색 엔진까지 실제로 띄우기로 했습니다.</p><ul><li><strong>환경 분리</strong>: QA 전용 compose로 MySQL(3307)과 OpenSearch(9201)를 따로 띄우고 데이터는 tmpfs에 둡니다. 매 실행이 시드 리셋으로 시작하므로 영속할 이유가 없습니다.</li><li><strong>커밋 단위 실행</strong>: 검증할 커밋을 git worktree로 체크아웃해 빌드하고 QA 포트(백엔드 8081, 프론트 3001)로 띄웁니다.</li><li><strong>날짜 고정 대신 오프셋</strong>: 서버가 LocalDate.now()로 연체를 계산하므로 연체 시드의 대출일을 “실행일 − 20일”로 넣어 언제 실행해도 같은 상태가 되게 했습니다.</li></ul><h4>3.2 큐와 직렬 워커</h4><p>QA 서비스는 요청이 Slack에서 왔는지 몰라도 되게 만들었습니다. n8n은 Slack 메시지를 아래처럼 정해진 형식으로 바꿔 POST /jobs로 보냅니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xv0hzDCiKSw9YtxN4bzNCg.png" /></figure><p>reply_to는 QA 서비스가 열어 보지 않습니다. 받은 그대로 결과에 붙여 n8n에 돌려줄 뿐이고 그 정보로 어느 스레드에 답할지는 n8n이 정합니다. 이렇게 나누면 나중에 GitHub PR처럼 다른 곳에서 요청을 받을 때도 QA 서비스 코드는 고치지 않고 n8n 워크플로만 추가하면 됩니다.</p><h4>3.3 자연어 요청 분류</h4><p>요청이 들어오면 먼저 이미 있는 시나리오로 검증할 수 있는지 판단합니다. 시나리오 목록(카탈로그)은 별도 파일 없이 테스트 함수의 docstring에서 만듭니다. 테스트를 하나 추가하면 곧바로 자연어 요청 대상이 됩니다.</p><pre>schema = {<br>    &quot;type&quot;: &quot;object&quot;,<br>    &quot;properties&quot;: {<br>        # enum으로 묶어 카탈로그 밖의 id가 나올 수 없게 한다.<br>        &quot;scenarios&quot;: {&quot;type&quot;: &quot;array&quot;, &quot;items&quot;: {&quot;type&quot;: &quot;string&quot;, &quot;enum&quot;: [s.id for s in scenarios]}},<br>        &quot;front_ref&quot;: {&quot;type&quot;: [&quot;string&quot;, &quot;null&quot;]},<br>        &quot;back_ref&quot;: {&quot;type&quot;: [&quot;string&quot;, &quot;null&quot;]},<br>        &quot;reason&quot;: {&quot;type&quot;: &quot;string&quot;},<br>    },<br>    ...<br>}</pre><p>시나리오 id를 JSON Schema enum으로 묶어 AI가 <strong>존재하지 않는 테스트 이름을 만들어낼 수 없게</strong> 했습니다. “프론트 main 브랜치로 확인해줘”처럼 브랜치를 언급하면 front_ref로 뽑습니다.</p><p>맞는 시나리오가 없으면 빈 배열이 나옵니다. 이때는 거절하지 않고 AI 탐색으로 넘깁니다. 접수 안내 문구도 QA 서비스가 만들어 돌려주므로 n8n은 분기 없이 전달만 합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F-EG7z7n7DSyhBlFG4tDCw.png" /><figcaption>시나리오에 존재하는 QA 요청</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C85UuLJkypssh2xSu27m1Q.png" /><figcaption>시나리오에 없는 QA 요청</figcaption></figure><h4>3.4 AI 탐색: 증거 없는 판정은 받지 않는다</h4><p>AI 탐색은 Claude Code가 Playwright MCP로 QA 환경의 화면을 사람처럼 조작하고 pass / fail / inconclusive(판단 불가)로 판정합니다.</p><p>가장 공들인 부분은 <strong>확인하지 않고 통과라고 말하는 것</strong>을 막는 일이었습니다. 판정 단계마다 스크린샷 파일명을 적게 하고 그 파일이 정말 있는지 확인합니다.</p><pre># 증거 검증: 언급한 스크린샷이 실제로 없으면 그 판정은 믿을 수 없다.<br>existing = {p.name for p in shots.rglob(&quot;*.png&quot;)}<br>for step in result[&quot;steps&quot;]:<br>    if step[&quot;screenshot&quot;] and Path(step[&quot;screenshot&quot;]).name not in existing:<br>        step[&quot;screenshot_missing&quot;] = True<br>cited = [s for s in result[&quot;steps&quot;] if s[&quot;screenshot&quot;] and not s.get(&quot;screenshot_missing&quot;)]<br>if result[&quot;verdict&quot;] != &quot;inconclusive&quot; and not cited:<br>   result[&quot;summary&quot;] = f&quot;[증거 없음 → 판단 불가로 강등]{result[&#39;summary&#39;]}&quot;<br>   result[&quot;verdict&quot;] = &quot;inconclusive&quot;</pre><h4>3.5 RAG로 판정 근거 붙이기</h4><p>AI 탐색이 “상식”으로 판정하면 기획 의도와 다른 기준으로 통과나 실패를 낼 수 있습니다. 이를 막으려고 요청과 관련된 기획서, 디자인 스펙, 과거 이력을 vault에서 검색해 프롬프트에 붙였습니다. 판정에 쓴 문서는 경로와 원문 인용으로 남기게 했습니다.</p><p>AI가 근거를 지어낼 수도 있으므로 인용문이 제공한 문서에 있는지 대조합니다.</p><pre># 근거 검증: 제공하지 않은 문서를 인용했거나 인용문이 그 문서에 없으면 지어낸 근거로 본다.<br>provided = {h.path: h.text for h in hits}<br>for ref in result[&quot;references&quot;]:<br>    source = provided.get(ref[&quot;path&quot;])<br>    ref[&quot;verified&quot;] = bool(source) and _normalize(ref[&quot;quote&quot;]) in _normalize(source)</pre><h4>3.6 실패 분석: 검증한 AI와 분석하는 AI를 나눈다</h4><p>테스트가 실패하면 다음 질문은 “그래서 어디를 고쳐야 하는가”입니다. 검증한 AI에게 이어서 묻지 않고 별도의 분석 AI를 실행합니다. 분석 AI는 실패 증거(스크린샷, API 로그)와 근거 문서, 그리고 검증한 바로 그 커밋의 코드 직접 읽습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j8VRYq7m8Qbhk0yE4G3n9g.png" /></figure><p>수정 후보는 repo / 파일 / 라인으로 받고 <strong>그 파일이 실제로 있고 그 줄 번호가 파일 길이 안에 있는지</strong> 확인해 verified로 표시합니다. 그럴듯하지만 존재하지 않는 위치는 이렇게 걸러집니다.</p><p>[실패 분석 결과 Slack 리포트 캡쳐 필요]</p><h4>3.7 결과 회신에 영상 추가</h4><p>코드를 모르는 요청자에게는 “정말 확인했는지”를 보여줄 방법이 더 필요했습니다. 그래서 통과/실패와 상관없이 스크린샷 뒤에 실행 영상을 함께 보냅니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ElMo1ju6ulnuX0XDCUHL1A.png" /></figure><p>AI 탐색 쪽은 Playwright MCP에 녹화 옵션(플래그)이 없었습니다. 대신 설정 파일로 브라우저 컨텍스트 옵션을 넘길 수 있어서 recordVideo로 세션 전체를 녹화했습니다. AI에게 “녹화를 시작해”라고 시키지 않으니 빠뜨릴 일이 없습니다. AI가 생각하는 동안 화면이 멈춰 있어 영상이 길어지는 점은 1.5배속으로 보완했습니다.</p><p>Playwright는 webm으로 녹화하므로 Slack에서 바로 재생되도록 H.264 mp4로 바꿉니다.</p><pre>cmd = [ffmpeg, &quot;-nostdin&quot;, &quot;-y&quot;, &quot;-i&quot;, str(src),<br>       &quot;-vf&quot;, f&quot;setpts=PTS/{speed},scale=trunc(iw/2)*2:trunc(ih/2)*2&quot;,  # 배속, 짝수 해상도<br>       &quot;-an&quot;, &quot;-c:v&quot;, &quot;libx264&quot;, &quot;-pix_fmt&quot;, &quot;yuv420p&quot;, &quot;-crf&quot;, &quot;28&quot;,<br>       &quot;-movflags&quot;, &quot;+faststart&quot;, str(dst)]</pre><p>n8n은 수정 사항이 없습니다. 출구 워크플로가 첨부 목록을 종류와 상관없이 받아 올리기 때문에, QA 서비스가 목록에 영상을 추가하는 것으로 끝났습니다. 변환이 실패해도 영상만 빠지고 검증 결과는 그대로 나갑니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9sjPTHmW1xfZwnsRTJ45qw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5pKa8RcxO7DoFdmPLyER4w.png" /><figcaption>Slack 결과 스레드의 스크린샷, 영상 첨부</figcaption></figure><h4>3.8 결과 기록: 검증이 다음 검증의 근거가 된다</h4><p>검증이 끝나면 결과를 vault의 QA 리포트/에 노트로 남기고 증분 색인합니다. 근거 문서와 과거 이력은 Obsidian 그래프에서 연결이 보이게 했습니다. 그래야 다음 실패 분석에서 “비슷한 과거 사례”로 검색됩니다.</p><p>순서는 회신 뒤에 기록합니다. 임베딩에 걸리는 시간만큼 요청자를 기다리게 할 수는 없기 때문입니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BK1jSuYTRqzO147kj8v4oQ.png" /><figcaption>vault QA 리포트</figcaption></figure><h3>4. 실제 실행 예시</h3><h4>4.1 시나리오 테스트로 처리되는 요청</h4><blockquote><em>@Library 오타 검색하면 수정 잘 되서 나오는지 확인해줘 (&quot;데미한&quot;을 검색하면 &quot;데미안&quot; 이 추천 검색에 뜨고 추천 검색어를 누르면 &quot;데미안&quot; 책이 잘 나오는지 확인해줘)</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UMPLtMXq47qYFHx6vbTvzg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26a5ca095964" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Quizly 쿼리 튜닝 (배치와 문제 조회 API, 부하 테스트로 검증하기)]]></title>
            <link>https://medium.com/@rnjscksdud1/quizly-%EC%BF%BC%EB%A6%AC-%ED%8A%9C%EB%8B%9D-%EB%B0%B0%EC%B9%98%EC%99%80-%EB%AC%B8%EC%A0%9C-%EC%A1%B0%ED%9A%8C-api-%EB%B6%80%ED%95%98-%ED%85%8C%EC%8A%A4%ED%8A%B8%EB%A1%9C-%EA%B2%80%EC%A6%9D%ED%95%98%EA%B8%B0-965577b924ab?source=rss-cfb68566ad84------2</link>
            <guid isPermaLink="false">https://medium.com/p/965577b924ab</guid>
            <category><![CDATA[mysql]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[backend-development]]></category>
            <dc:creator><![CDATA[chanyoung Kwon]]></dc:creator>
            <pubDate>Fri, 20 Nov 2026 06:16:01 GMT</pubDate>
            <atom:updated>2026-11-20T06:16:01.544Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*alHCd5YAWNplSSgDC13Wdw.png" /></figure><h3>1. 들어가며</h3><p>Quizly는 사용자가 문제를 풀 때마다 solve_history에 한 줄씩 쌓입니다. 이 테이블을 읽는 기능은 두 가지입니다. 매일 새벽 전날 풀이를 집계하는 <strong>일일 통계 배치</strong>, 그리고 지금까지 푼 문제를 날짜/주제별로 다시 보여주는 <strong>문제 조회 API</strong>입니다.</p><p>초기에는 둘 다 멀쩡했습니다. 그런데 서비스를 오래 운영할수록 문제 조회 페이지의 로딩이 점점 길어졌습니다.</p><p>운영 기간이 늘어 사용자별 데이터가 쌓이면서 생긴 문제라고 보고, 동일한 사양의 개발 서버에서 재현해 보았습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wu-v6H3_CMHBlCqlJbvNXQ.png" /><figcaption>데이터 규모별 배치 Job 실행 시간</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R4Dr7800vIYwEgJTPyRWzw.png" /><figcaption>데이터 규모별 사용자 조회(Reader) 시간</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ddELGsAVfZYGuJ7Hmj6yZg.png" /></figure><p>전날 풀이 양은 그대로인데, <strong>전체 이력이 쌓일수록</strong> 배치가 느려졌습니다. 문제 조회 API도 비슷했습니다. 이력이 가장 많은 사용자는 한 번 요청에 4MB짜리 응답을 받고 있었습니다.</p><p>이 글에서는 두 기능을 어떻게 진단하고 고쳤는지 그리고 그 효과를 부하 테스트로 어떻게 확인했는지 정리합니다.</p><h3>2. 테스트 환경</h3><h4>2.1 실서버 분포를 유지한 더미 데이터</h4><p>더미 데이터를 만들기 전에 실서버 데이터의 모양부터 확인했습니다. 개인정보가 나오지 않도록 건수와 비율만 뽑았습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pWR4FUxNsDuUk-09gXmRoA.png" /></figure><p>생성기는 Java로 만들었습니다. SQL 프로시저 대신 코드로 만든 이유는 <strong>서비스 로직과 같은 순서로 데이터를 쌓고 싶었기 때문</strong>입니다. 문제를 만들면 “초안 행이 생성 → 채점하면 그 행이 갱신 → 오답 노트에서 다시 풀면 새 행이 추가”되는 흐름을 그대로 따랐습니다.</p><pre>for (QuizRow quiz : memberQuizzes) {<br>    if (rng.nextDouble() &lt; UNSOLVED_RATIO) {<br>        // 문제 생성 시 저장되는 초안(CreateMemberQuizzesService)<br>        rows.add(draft(quiz));<br>    } else {<br>        // 채점 시 초안 행을 갱신(GradeMemberQuizzesService)<br>        // ...<br>    }<br>    // 오답 노트에서 다시 풀면 새 행 추가(GradeMemberWrongQuizzesService), 맞힐 때까지 최대 3회<br>    // ...<br>}</pre><p>나머지 규칙은 이렇게 정했습니다.</p><ul><li><strong>사용자별 풀이량은 실서버의 분포</strong>를 따릅니다. 소수의 헤비 유저가 이력의 큰 몫을 차지하는 실서버 모양을 맞추기 위해서입니다.</li><li><strong>문제는 세트 단위</strong>(회원 10문제)로 만들고, 같은 세트는 주제와 생성 시각을 공유합니다.</li><li><strong>사용자마다 관심 주제를 3~15개</strong> 정해 두고 그 안에서만 문제를 만듭니다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mSV5fqtS8DdVn6OeHY0PQg.png" /></figure><h4>2.2 부하 테스트 구성</h4><p>자원은 실서버에 맞췄습니다. 실서버는 현재 OCI에서 앱 서버와 DB 서버를 각각 <strong>CPU 1개, 메모리 6GB</strong>로 쓰고 있어 개발 서버도 똑같이 구성했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DzBg5CO4pWvDBHt1sO7zlA.png" /><figcaption>실서버 OCI 사양</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7U6fBhAXdfrKejNbN2gNVg.png" /><figcaption>개발 서버 OCI 사양</figcaption></figure><p>부하는 nGrinder로 6분씩 걸었습니다. 결과 표의 TPS, p50, p95는 앱 서버 지표(Prometheus)에서 부하가 안정된 뒤 약 4분 구간만 잘라 계산했습니다. nGrinder 화면의 TPS는 워밍업을 포함한 6분 전체를 클라이언트에서 센 평균이라, 표의 값과 조금 다릅니다.</p><h3>3. 배치</h3><h4>3.1 인덱스 순서에 따른 차이</h4><p>배치는 전날 풀이한 사용자를 20명씩 읽고(Reader), 사용자마다 통계를 계산해(Processor) 저장합니다. 두 쿼리 모두 조건 컬럼이 user_id와 submitted_at 두 개라, 인덱스 순서를 바꿔 가며 배치 1회 분량을 그대로 실행해 비교했습니다(200배 데이터, 기준일 하루치 활동 사용자 531명).</p><p>표의 시간은 실행 계획 한 번의 시간이 아니라, 배치 1회에 나가는 쿼리를 log로 모두 모아 더한 값입니다(3회 평균). 사용자 조회는 Step 두 개가 각각 20명씩 28페이지(마지막 빈 페이지 확인 포함)를 읽어 56회, 통계 쿼리는 사용자마다 1회씩 531회 실행됩니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K5DRR2YD7F0n7GV3mbVC3Q.png" /></figure><p>쿼리마다 맞는 순서가 반대였습니다.</p><p><strong>3.1.1 사용자 조회: (submitted_at, user_id)</strong></p><pre>SELECT u.* FROM user u<br>WHERE EXISTS (<br>  SELECT 1 FROM solve_history sh<br>  WHERE sh.user_id = u.id<br>  AND sh.submitted_at &gt;= :start AND sh.submitted_at &lt; :end<br>)<br>ORDER BY id LIMIT 20</pre><p>인덱스가 없으면 페이지마다 테이블 전체를 훑습니다. 그래서 비용이 전날 데이터 양이 아니라 <strong>전체 테이블 크기 × 페이지 수</strong>에 비례했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bLYaeZ4WnRQi1IuhecFs6w.png" /><figcaption>사용자 조회 — 인덱스 없음 실행 계획(전날 1,806건을 찾으려고 44만 건을 모두 읽는다.)</figcaption></figure><p>“같다(=) 조건을 앞에”라는 원칙대로라면 (user_id, submitted_at) 인덱스가 적합해 보입니다. 동등 비교 컬럼을 인덱스 앞쪽에 두면 user_id로 스캔 범위를 먼저 좁힐 수 있고, 범위 조건인 submitted_at은 그 뒤에서 처리되어 읽는 인덱스 구간이 최소화되기 때문입니다.</p><p>그런데 사용자 조회에서는 (submitted_at, user_id)보다 27배 느렸습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qz12JTrk_w5NtOIN4bVumg.png" /><figcaption>사용자 조회 — (user_id, submitted_at) 실행 계획(전날 1,806건을 찾으려고 44만 건을 모두 읽는다.)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sTOBJyWeO0f15SE7aE5UXg.png" /><figcaption>사용자 조회 — (submitted_at, user_id) 실행 계획(전날 범위만 읽는다)</figcaption></figure><p>sh.user_id = u.id는 <strong>상관 서브쿼리 조건(서브쿼리 안에서 바깥 쿼리의 컬럼을 참조하는 서브쿼리)</strong>입니다. 바깥 행마다 값이 바뀌니 탐색의 시작점이 될 수 없습니다. 이 쿼리에서 진짜 상수는 날짜 범위뿐이라, 범위를 앞에 둔 쪽이 맞았습니다.</p><p><strong>3.1.2 통계 쿼리: (user_id, submitted_at)</strong></p><p>통계 쿼리는 사용자 한 명의 전날 첫 풀이를 문제 유형별, 시간대별로 집계합니다. 사용자 조회로 찾은 사용자마다 한 번씩 실행됩니다.</p><pre>-- 문제 유형별 통계 (시간대별 통계도 같은 조건으로 HOUR(submitted_at) 기준 집계)<br>SELECT q.quiz_type, COUNT(sh.id), SUM(CASE WHEN sh.is_correct = 1 THEN 1 ELSE 0 END)<br>FROM solve_history sh<br>JOIN quiz q ON q.id = sh.quiz_id<br>WHERE sh.user_id = :userId<br>AND sh.submitted_at &gt;= :start AND sh.submitted_at &lt; :end<br>AND sh.is_first = 1<br>GROUP BY q.quiz_type</pre><p>인덱스가 없으면 외래 키 인덱스(user_id)로 그 사용자의 이력 전체를 읽은 뒤 날짜와 is_first를 거릅니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5aDA-MZervm2USqWqVqzJg.png" /><figcaption>문제 유형별 통계 — 인덱스 없음 실행 계획(그 사용자의 하루치만 정확히 읽는다)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*33R68A_7K1PvjqWd_BXc_A.png" /><figcaption>문제 유형별 통계 — (user_id, submitted_at) 실행 계획(그 사용자의 하루치만 정확히 읽는다.)</figcaption></figure><p>통계 쿼리는 반대였습니다. 배치가 user_id = 1처럼 값을 넣어 실행하므로 user_id가 진짜 상수입니다.</p><p><strong>3.1.3 두 인덱스를 모두 만들다</strong></p><p><strong>두 인덱스를 모두 만들었습니다.</strong> 사용자 조회는 (submitted_at, user_id), 통계 쿼리와 오늘의 학습 통계 API는 (user_id, submitted_at)를 씁니다. 두 인덱스를 둔 상태에서 배치 1회 분량을 다시 실행했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XJq0_-TviAXe_KO9xCD05g.png" /></figure><h4>3.2 배치 실행 결과</h4><p>쿼리가 17배 빨라졌다고 배치도 17배 빨라질까요? 200배 데이터에서 튜닝 전후로 배치를 3번씩 실행해 단계별 시간을 비교했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v8-ZM7Xo1l4FdCngdxowAg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZpO6fsVN9XWmMuwDhtraNA.png" /><figcaption>배치 튜닝 전후 Job 실행 시간</figcaption></figure><p>Reader는 13배 빨라졌지만 Job 전체는 36% 줄었습니다. 남은 시간 대부분이 사용자마다 통계를 계산하고 저장하는 Processor와 Writer이기 때문입니다. 대신 <strong>Reader 비용이 전체 이력이 아니라 전날 데이터 양에 비례하게</strong> 됐습니다. 데이터가 계속 쌓여도 배치가 그만큼 느려지지 않습니다.</p><h3>4. API</h3><h4>4.1 인덱스만으로는 부족했다</h4><p>문제 조회 API는 푼 문제를 날짜나 주제로 묶어 보여줍니다. 기존 구현은 <strong>그룹 10개 단위로 페이징하고, 그룹 안의 문제는 전부</strong> 내려줬습니다.</p><pre>// 그룹(날짜 또는 주제) 10개를 페이징으로 가져온 뒤<br>Page&lt;String&gt; topicPage = solveHistoryRepository.findDistinctQuizTopicsByUser(user, pageRequest);</pre><pre>// 그 그룹에 속한 문제의 최신 풀이를 개수 제한 없이 조회<br>solveHistoryList = solveHistoryRepository.findLatestSolveHistoriesByUserAndTopics(<br>    user, topicPage.getContent());</pre><p>이력이 적을 때는 그룹 하나에 든 문제가 몇 개 안 돼 티가 나지 않았습니다. 사용자가 만든 문제를 로딩 없이 한 번에 보여줄 수 있어 좋은 방법이기도 했습니다. 하지만 이력이 가장 많은 사용자는 첫 페이지(주제 10개)에만 1만 5천여 문제가 담겨 응답이 4MB였습니다. <strong>사용자의 이력이 쌓이는 만큼 응답이 커지는 구조</strong>였고 처음 설계할 때 이 성장을 고려하지 못했습니다.</p><p>그래도 인덱스로 어느 정도 버틸 수 있지 않을까요? 먼저 기존 쿼리부터 분석했습니다.</p><p><strong>4.1.1 튜닝할 쿼리와 실행 계획</strong></p><p>가장 무거운 건 그룹에 속한 문제의 최신 풀이를 가져오는 쿼리였습니다. 문제 조회와 틀린 문제 조회는 is_correct 조건 하나만 다릅니다.</p><pre>-- 날짜 그룹은 q.topic 대신 CAST(q.createdAt AS LocalDate) IN :dates<br>SELECT DISTINCT sh FROM SolveHistory sh<br>LEFT JOIN FETCH sh.quiz q<br>LEFT JOIN FETCH q.options<br>WHERE sh.user = :user<br>-- AND sh.isCorrect = FALSE  (틀린 문제 조회)<br>AND q.topic IN :topics<br>AND (sh.quiz.id, sh.createdAt) IN (<br>  SELECT sh2.quiz.id, MAX(sh2.createdAt)<br>  FROM SolveHistory sh2<br>  WHERE sh2.user = :user<br>  GROUP BY sh2.quiz.id<br>)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9dAqMrGTnGjcjfJdjXquog.png" /><figcaption>인덱스 적용 전 문제 조회 실행 계획 — 헤비 유저</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BVkyM7CmIM6Z1Cio_s0H2Q.png" /><figcaption>인덱스 적용 전 문제 조회 실행 계획 — 중간 사용자</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*omiC19mrra9LYcmrZpqPIg.png" /><figcaption>인덱스 적용 전 문제 조회 실행 계획 — 가벼운 사용자</figcaption></figure><p>외래 키 인덱스(user_id)로 사용자의 이력 29,008건을 찾지만, 이 인덱스에는 quiz_id와 created_at이 없어 행마다 테이블을 다시 읽습니다. 최신 풀이를 고르는 서브쿼리도 같은 29,008건을 테이블에서 읽은 뒤 임시 테이블로 묶습니다.</p><p><strong>4.1.2 인덱스 후보</strong></p><p>두 쿼리는 user_id(틀린 문제는 is_correct까지)로 이력을 좁히고, quiz_id별로 묶어 MAX(created_at)을 구합니다. 조건 컬럼을 앞에, 묶는 컬럼과 최댓값을 구할 컬럼을 뒤에 두면 테이블을 거치지 않고 인덱스만으로 처리할 수 있습니다(커버링 인덱스).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GWDg4pKFmB_pOp5l0geuhQ.png" /></figure><p><strong>4.1.3 인덱스 하나로 충분하지 않을까?</strong></p><p>후보를 정리하다 보니 두 번째 인덱스만으로도 문제 조회를 처리할 수 있을 것 같았습니다. (user_id, is_correct, quiz_id, created_at DESC)도 user_id로 시작하고, 쿼리에 필요한 quiz_id와 created_at을 모두 갖고 있습니다. is_correct 조건이 없어도 user_id = 1 범위만 읽으면 커버링 인덱스로 쓸 수 있습니다.</p><p>잃는 건 정렬 순서뿐입니다. 이 인덱스는 is_correct별로 나뉘어 있어 quiz_id 순서가 아니므로, GROUP BY quiz_id를 임시 테이블로 처리해야 합니다. 이 차이가 실제로 얼마나 되는지 두 단계로 확인했습니다.</p><p>먼저 두 인덱스를 모두 만들고, 문제 조회에서 옵티마이저가 무엇을 고르는지 봤습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DtJK5FsN025wCl6mVRgfcQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S1wVglp0sfFylX5m7JPWIA.png" /><figcaption>두 인덱스가 모두 있을 때 실행 계획 — 헤비 유저(user_id, is_correct, quiz_id, created_at)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aoH-cVjZ3HuEt4xR7UOAPw.png" /><figcaption>두 인덱스가 모두 있을 때 실행 계획 — 중간 사용자 (user_id, quiz_id, created_at)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wBk3BQXkmKiss5EwL1YIlA.png" /><figcaption>두 인덱스가 모두 있을 때 실행 계획 — 가벼운 사용자 (user_id, quiz_id, created_at)</figcaption></figure><p>이력이 가장 많은 사용자는 문제 조회 전용 인덱스가 있는데도 이미 is_correct 인덱스를 쓰고 있었습니다. 두 인덱스 모두 커버링이 되니, 옵티마이저 입장에서는 비용이 비슷한 후보였던 것입니다.</p><p>다음으로 (user_id, quiz_id, created_at)를 빼고 같은 쿼리를 실행했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PX0L14mX8eciII4KBfPDFg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yHl_HjMwHf9o_9g7d2vH3Q.png" /><figcaption>인덱스 하나만 있을 때 실행 계획 — 헤비 유저 (user_id, is_correct, quiz_id, created_at)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pUswuXoBj2U4QXthYn_Adg.png" /><figcaption>인덱스 하나만 있을 때 실행 계획 — 중간 사용자 (user_id, is_correct, quiz_id, created_at)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J83NI7d7zePmyvqhLuuY7Q.png" /><figcaption>인덱스 하나만 있을 때 실행 계획 — 가벼운 사용자 (user_id, is_correct, quiz_id, created_at)</figcaption></figure><p>모든 사용자가 is_correct 인덱스로 옮겨 갔고, 차이는 측정 오차 수준이었습니다. 그래서 <strong>(user_id, is_correct, quiz_id, created_at DESC) 하나만 남겼습니다.</strong> 인덱스 하나를 덜 두면 그만큼 공간과 쓰기 비용도 줄어듭니다(6장).</p><p><strong>4.1.4 인덱스 적용 후 부하 테스트</strong></p><p>다만 인덱스를 적용해도 읽는 양은 그대로였습니다. 테이블 대신 인덱스를 읽게 됐을 뿐, 이력 29,008건을 두 번 읽고 15,650행을 반환하는 건 같습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8XobIuZXs4PotDVXBmLJVg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6PGxasPpzTHPTDR90yGbYA.png" /><figcaption>기존 코드 인덱스 없음 nGrinder 결과</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lE-0qNf4u8aGgqQJF1KX3Q.png" /><figcaption>기존 코드 인덱스 적용 nGrinder 결과</figcaption></figure><p>nGrinder 화면의 TPS(89.6 → 127.2)는 6분 전체 평균이고, 표는 안정 구간 기준입니다.</p><p>1.5배 좋아졌지만 p95는 여전히 600ms 안팎이었습니다. 찾는 속도는 빨라져도 <strong>읽고 반환해야 하는 행 수가 그대로</strong>였기 때문입니다.</p><h4>4.2 구조 변경: 한 번에 읽는 양을 페이지 크기로 고정</h4><p>페이징 단위를 그룹에서 문제로 바꿨습니다. 그룹 목록과 그룹 안의 문제를 각각 API로 나눴습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fh_4wK0A1J2BPUvIojsG7A.png" /></figure><p>틀린 문제(/quizzes/wrong)도 같은 구조로 바꿨습니다. 이제 문제 조회 비용은 사용자의 이력이 아니라 <strong>페이지 크기</strong>에 비례합니다.</p><p>페이징을 넣으면서 하나 걸리는 점이 있었습니다. 기존 쿼리는 선택지(options 컬렉션)까지 fetch join으로 가져왔는데, 컬렉션 fetch join에 페이징을 걸면 Hibernate가 <strong>전체를 메모리로 가져와 페이징</strong>합니다(HHH90003004).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uXsTeZHE7xXE11mE3DzLpA.png" /><figcaption>HHH90003004 경고와 LIMIT 없는 SQL</figcaption></figure><p>이 때문에 페이징 쿼리는 quiz까지만 join하고, 선택지는 @BatchSize로 페이지의 문제 20개분을 IN 쿼리 한 번에 가져오게 했습니다.</p><pre>@BatchSize(size = 100)<br>@ElementCollection(fetch = FetchType.LAZY)<br>@CollectionTable(name = &quot;quiz_options&quot;, joinColumns = @JoinColumn(name = &quot;quiz_id&quot;))<br>private List&lt;String&gt; options = new ArrayList&lt;&gt;();</pre><h4>4.3 탐색 시작점을 바꾸다</h4><p>구조를 바꿨는데도 쿼리는 여전히 사용자의 풀이 이력 전체에서 출발했습니다. 문제마다 최신 풀이만 남기는 서브쿼리 때문입니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9gZwo2nyRt3_gdBHRS8_mA.png" /><figcaption>quiz 기준 탐색 전 실행 계획 (4.1 인덱스 적용)</figcaption></figure><p>4.1의 인덱스 덕분에 테이블 대신 인덱스만 읽지만 20개를 보여주려고 여전히 이력 29,008건을 두 번 읽고 그때마다 quiz를 PK로 찾아갑니다. 날짜 조건도 CAST(created_at AS DATE)라 인덱스로 거를 수 없어 다 모은 뒤에야 정렬해 20개를 고릅니다. LIMIT 20이 있어도 일찍 멈출 수 없는 구조입니다.</p><p>하지만 Quizly에서 채점은 <strong>자기 문제만 풀 수 있게</strong> 막고 있습니다(quiz.getUser().equals(user)). 즉 풀이자는 항상 문제 소유자이고 사용자의 문제는 quiz.user_id로 바로 찾을 수 있습니다. 그래서 탐색을 <strong>사용자의 문제에서 시작</strong>하고 최신 풀이는 문제마다 찾게 바꿨습니다.</p><p>논리적으로는 중복 조건이지만, 인덱스를 타도록 일부러 이 조건을 넣었습니다.</p><pre>-- SolveHistoryRepository.findLatestSolveHistoriesByUserAndDateTimeRange (JPQL)<br>SELECT sh FROM SolveHistory sh<br>JOIN FETCH sh.quiz q<br>WHERE q.user = :user<br>AND sh.user = :user<br>-- AND CAST(q.createdAt AS LocalDate) = :date<br>AND q.createdAt &gt;= :startDateTime AND q.createdAt &lt; :endDateTime<br>-- AND (sh.quiz.id, sh.createdAt) IN (<br>--   SELECT sh2.quiz.id, MAX(sh2.createdAt) FROM SolveHistory sh2<br>--   WHERE sh2.user = :user GROUP BY sh2.quiz.id)<br>AND sh.createdAt = (<br>  SELECT MAX(sh2.createdAt) FROM SolveHistory sh2 WHERE sh2.quiz = q<br>)<br>ORDER BY q.createdAt DESC, q.id DESC</pre><p>인덱스는 quiz(user_id, created_at)와 quiz(user_id, topic, created_at)를 추가했습니다. 정렬 순서까지 인덱스와 같아서, 인덱스를 거꾸로 읽다가 20개가 차면 멈춥니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zp4zjkJoxeeqnGsMOD1c2g.png" /><figcaption>quiz 기준 탐색 후 실행 계획</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OmwEkh_a7IsxFLhlThDtCA.png" /></figure><p>모든 쿼리를 바꾼 건 아닙니다. 틀린 문제의 그룹 목록은 “최신 풀이가 오답인 문제”를 세야 해서, quiz 기준으로 바꾸면 문제마다 서브쿼리가 돌아 오히려 느렸습니다(70ms → 115~267ms). 이 쿼리는 기존 형태에 인덱스만 두었습니다.</p><pre>SELECT q.topic AS groupKey, COUNT(sh) AS quizCount<br>FROM SolveHistory sh<br>JOIN sh.quiz q<br>WHERE sh.user = :user<br>AND sh.isCorrect = FALSE<br>AND (sh.quiz.id, sh.createdAt) IN (<br>  SELECT sh2.quiz.id, MAX(sh2.createdAt) FROM SolveHistory sh2<br>  WHERE sh2.user = :user GROUP BY sh2.quiz.id)<br>GROUP BY q.topic<br>ORDER BY q.topic ASC</pre><p>사용자의 오답 이력을 (user_id, is_correct, quiz_id, created_at) 인덱스에서 바로 읽고 문제별 최신 풀이도 같은 인덱스로 구하기 때문에 이 형태가 더 빨랐습니다.</p><p>바꾼 쿼리와 유지한 쿼리를 정리하면 이렇습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*39t4W8Q5-KCVSlTGp5_Xew.png" /></figure><p>쿼리를 크게 바꾼 만큼 결과가 같은지 검증했습니다. 사용자 41명 × API 4개로 튜닝 전후 응답 596건을 비교해 문제 1,783건이 모두 일치하는 것을 확인했습니다.</p><h4>4.4 부하 테스트 결과</h4><p>같은 시나리오(헤비 1/4 + 무작위 3/4, 40 vuser)로 측정했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jd__TRs-gwF1XqjVyxfgOg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0B2eivW9DUymbXDgxSjtPg.png" /><figcaption>새 구조 튜닝 전 nGrinder 결과</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oBoYk4SASpcItsqTvUEGZw.png" /><figcaption>새 구조 튜닝 후 nGrinder 결과</figcaption></figure><p>nGrinder 화면의 TPS(158.9 → 513.8)는 6분 전체 평균입니다. 튜닝 후에는 처음 2분가량 TPS가 올라가는 워밍업 구간이 있어, 전체 평균이 표(안정 구간)보다 낮게 나옵니다.</p><p>튜닝 전에는 헤비 유저의 이력 전체 스캔이 MySQL CPU를 채워서, 가벼운 사용자의 요청까지 함께 기다렸습니다. 튜닝 후에는 DB 부담이 줄어 같은 자원에서 더 많은 요청을 처리했습니다.</p><p>기존 코드와도 비교했습니다. 다만 기존 코드는 화면 하나에 요청 1개, 새 구조는 그룹 목록과 문제 조회로 요청 2개라 <strong>화면 기준</strong>으로 맞췄습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y--WmhtOwVb2s9njkIlP5A.png" /></figure><h3>5. 배치와 API의 인덱스 힌트 적용 차이</h3><p>인덱스를 만들어도 어느 인덱스를 쓸지는 옵티마이저가 정합니다. 여기서 배치와 API에는 서로 다른 방법을 택했습니다.</p><p><strong>배치는 </strong><strong>USE INDEX로 고정했습니다.</strong> 사용자 조회는 두 인덱스가 모두 후보라, 옵티마이저가 (user_id, submitted_at)를 고르면 3.1의 느린 계획으로 떨어집니다. 실제로 이전에 측정했을 때 옵티마이저가 비용을 <strong>186배 잘못 추정해</strong> 느린 인덱스를 고른 적이 있습니다.</p><p><strong>API는 힌트를 두지 않았습니다.</strong> 탐색 시작점이 quiz.user_id = 상수라 후보가 명확합니다. 이력이 21건, 337건, 29,008건인 사용자로 실행 계획을 확인해 보니 네 쿼리 모두 quiz 인덱스를 골랐습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JdVjLAqjGeL53lmK6UJ7vw.png" /></figure><p>힌트를 고를 때는 <strong>인덱스가 없을 때 어떻게 되는지</strong>도 따져봤습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zcDEpbQsGB-SVrvl0TlWuQ.png" /></figure><p>그래서 배치는 즉시 실패하는 USE INDEX를 쓰고, 인덱스 관리 파일에 “힌트로 고정된 인덱스”라고 주석을 남겼습니다. API에 힌트가 필요해진다면 실패해도 응답이 유지되는 옵티마이저 힌트를 쓸 생각입니다.</p><pre>queryProvider.setWhereClause(<br>    &quot;WHERE EXISTS (&quot; +<br>        // &quot;  SELECT 1 FROM solve_history sh&quot; +<br>        &quot;  SELECT 1 FROM solve_history sh USE INDEX (idx_solve_history_submitted_user)&quot; +<br>        &quot;  WHERE sh.user_id = u.id&quot; +<br>        // ...<br>        &quot;)&quot;<br>);</pre><h3>6. 인덱스의 대가 (쓰기 비용)</h3><p>인덱스는 공짜가 아닙니다. 이번에 solve_history에 3개, quiz에 2개를 추가했으니, INSERT 한 번에 인덱스 항목도 그만큼 더 써야 합니다. 채점처럼 인덱스 컬럼(is_correct, submitted_at)을 바꾸는 UPDATE는 인덱스 항목을 옮기는 비용도 듭니다. 읽기만 재고 넘어가면 반쪽짜리 판단이라, 쓰기도 측정했습니다.</p><p>원본을 건드리지 않도록 200배 데이터의 두 테이블을 복사해서 측정했습니다. 쓰기는 서비스에서 실제로 일어나는 세 가지를 그대로 재현했고, 사용자 500명을 돌아가며 써서 삽입 위치가 인덱스 전체에 흩어지게 했습니다. 인덱스 없음(FK 인덱스만)과 인덱스 5개 상태를 번갈아 6번씩, 회당 1,000번 반복했습니다. 첫 회는 복사 직후라 두 상태 모두 크게 튀어 워밍업으로 보고 제외했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aZdRfQmPqA3AcIQ2MxMjsA.png" /></figure><p>4.1에서 뺀 (user_id, quiz_id, created_at) 인덱스까지 6개를 뒀을 때는 문제 세트 생성이 +0.48ms였습니다. 채점은 +0.14ms로 거의 같았는데, 그 인덱스에는 채점이 바꾸는 컬럼이 없기 때문입니다.</p><p>비율로는 꽤 늘었습니다. 하지만 절대값은 행당 13~18µs, 요청 하나로 보면 1ms가 안 됩니다. 같은 인덱스로 헤비 유저 조회는 107ms에서 1.7ms로, 배치 사용자 조회는 5.16초에서 0.40초로 줄었습니다. Quizly는 문제를 한 번 만들고 여러 번 다시 보는 읽기 위주 서비스라, 이 정도 쓰기 비용은 감수할 만하다고 판단했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qcOT1f0mQu17BUFPpuElJA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5q1mMAoCMP3bw_2mIKFpow.png" /><figcaption>테이블별 데이터와 추가한 인덱스 크기</figcaption></figure><p>추가한 인덱스만 약 81MB로, 데이터(91MB)와 비슷한 크기입니다. MySQL 기본 버퍼 풀이 128MB이지만 실서버 DB는 램이 6GB로 여유가 있어서 테이블과 인덱스를 모두 메모리에 올려 둘 수 있습니다.</p><h3>7. 정리</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bpler25AUcDK5jR1ssV3Og.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=965577b924ab" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI 모의고사 생성 API 성능 개선(Prompt Routing, Chunk, Async)]]></title>
            <link>https://medium.com/@rnjscksdud1/ai-%EB%AA%A8%EC%9D%98%EA%B3%A0%EC%82%AC-%EC%83%9D%EC%84%B1-api-%EC%84%B1%EB%8A%A5-%EA%B0%9C%EC%84%A0-prompt-routing-chunk-async-ab74ddf3994e?source=rss-cfb68566ad84------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab74ddf3994e</guid>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[backend-development]]></category>
            <dc:creator><![CDATA[chanyoung Kwon]]></dc:creator>
            <pubDate>Fri, 20 Nov 2026 05:00:51 GMT</pubDate>
            <atom:updated>2026-11-20T05:00:51.274Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong><em>Quizly</em></strong><em>는 사용자 학습 데이터를 기반으로 LLM으로 문제를 자동 생성합니다. 문제 생성 QA 과정에서 몇 가지 문제를 발견했고 이를 어떻게 분석하고 해결했는지 공유합니다.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a6BaYJcVASL9zLr3JBda2A.png" /><figcaption>모의고사 생성 API 전체 구조 (Prompt Routing, Chunking, Async, Structured Outputs)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UcmyagPX5Rt7F9L79fqqlQ.png" /><figcaption>모의고사 생성 API 구조 스케치</figcaption></figure><h3>1. 초기 시스템의 구조와 문제점</h3><h4>1.1 현재 상황</h4><p>Quizly는 <a href="https://blog.naver.com/n_cloudplatform/223992345150">AI 포텐데이 결선</a>에 진출을 하면서 네이버의 지원을 받았으며 NCP와 HyperCLOVA X를 사용해야 하는 환경에서 진행하고 있습니다.</p><p>기존 시스템은 FIND_CORRECT, FIND_MATCH, ESSAY 등 6가지 문제 유형을 생성하기 위해 5,096자 규모의 단일 프롬프트를 사용했습니다. 여기에 사용자 데이터(약 1000자~10,000자)가 더해져 AI가 한 번에 처리해야 할 정보량이 지나치게 많았습니다.</p><p>유형(FIND_CORRECT, FIND_MATCH, ESSAY 등)을 생성하기 위해 5,096자짜리 단일 프롬프트를 사용했습니다. 여기에 사용자 데이터(1,000자~10,000자)까지 붙으니 AI가 한 번에 소화해야 할 양이 너무 많았습니다.</p><p><strong>사용 중인 프롬프트</strong></p><pre>[역할]<br>너는 &#39;출제 계획&#39;을 100% 정확하게 수행하는 &quot;25개 문제 생성 엔진&quot;이다.<br>너의 유일한 임무는 입력된 &#39;작업 알고리즘&#39;을 기계적으로 따르는 것이며, 어떠한 창의성이나 자율적 판단, 규칙 해석도 허용되지 않는다.<br>모든 문제의 사실적 근거는 &#39;사용자 정리 내용&#39;에서만 가져와야 하며, 외부 지식이나 추론은 절대 금지된다.<br>너의 유일한 존재 목적은 [입력]를 받아, 아래의 [절대 원칙]들을 100% 기계적으로 수행하여 최상위 레벨의 길이가 정확히 25인 JSON 배열을 출력하는 것이다.<br><br>[절대 원칙 (Absolute Principles)]<br>1.  허용 유형 절대 준수: &#39;1단계&#39;에서 식별된 &#39;허용 유형 목록&#39;에 없는 유형이 최종 결과물에 단 하나라도 포함될 경우, 이는 시스템의 치명적인 오류(Fatal Error)로 간주한다.<br>2.  형식 절대 준수<br>    : [유형별 질문 형식 규칙]을 포함하여 &#39;[유형별 생성 상세 명세]&#39;에 정의된 모든 규칙, 특히 FIND_MATCH의 options 필드는 반드시 JSON 배열(List of Strings)이어야 한다.<br>    : 입력의 &quot;문제 예시&quot;에 있는 형식만 생성 가능 (입력 이외의 형식이 반환된다면 이는 시스템의 치명적인 오류)<br>3. 개수 절대 준수 : 최종 결과물은 반드시 25개 문제 객체를 포함한 JSON 배열이어야 합니다.<br>4. FIND_CORRECT 유형의 질문에 &#39;아닌&#39;, &#39;않은&#39;, &#39;없는&#39;, &#39;틀린&#39;, &#39;못한&#39; 등의 부정 표현이 포함되는 것은 가장 중대한 치명적 오류(Fatal Error)이다.<br>... (이하 생략: 입력 형식, 작업 알고리즘, 유형별 생성 상세 명세, 출력 형식 등 — 전체 5,096자)</pre><h4>1.2 주요 발견 이슈</h4><ul><li><strong>일관성 저하</strong> → AI가 여러 유형의 규칙을 혼동해서 ’옳은 것’을 찾는 문제에 ’틀린 것’의 특징이 섞이는 등 품질이 떨어졌습니다.</li><li><strong>문항 수 미달</strong> → 20~25문항을 요청해도 AI가 5~17개만 반환하는 등 출제 개수가 유동적이었습니다.</li><li><strong>JSON 파싱 실패</strong> → 프롬프트 지시만으로는 JSON 규격을 완벽하게 지키지 못해 백엔드에서 파싱 에러가 자주 났습니다.</li><li><strong>응답 지연</strong> → 정확도를 높이려고 모델의 ‘추론(Thinking)’ 옵션을 켜면 응답 시간이 5분에서 10분까지 늘어났습니다.</li></ul><h3>2. 리팩토링 목표</h3><h4>2.1 일관성</h4><ul><li>항상 정확히 20개의 문제 or 추후 기획에 따라 원하는 문제의 수를 생성해야 한다. (Structured Outputs)</li><li>항상 동일한 JSON 형식으로 반환되어야 한다. (Structured Outputs)</li></ul><h4>2.2 정확성</h4><ul><li>각 문제 유형은 프롬프트에 명시된 모든 조건을 완벽하게 만족해야 한다. (Structured Outputs + Prompt Routing &amp; Post-processing, Chunking)</li><li>동일하거나 비슷한 문제가 나오지 않아야 한다. (Chunking)</li></ul><h4>2.3 사용성</h4><ul><li>사용자가 입력한 데이터의 전체 범위에서 편중 없이 골고루 문제를 출제해야 한다. (Chunking)</li><li>기획상 API 반환 시간이 최대 5분 이내로 작동해야 하며 빠를수록 좋다. (Async(병렬처리) 해결)</li></ul><h3>3. 기술 적용 (해결 과정)</h3><h4>3.1 Structured Outputs (HCX-007)</h4><p>JSON 파싱 오류와 문항 수 불일치를 해결하려고 Structured Outputs 기능을 도입했습니다.</p><p><strong>구현</strong></p><p>AI 요청 시 ResponseFormat 필드에 사용자가 정의한 JSON Schema를 직접 전달했습니다. 특히 리스트 내 요소 개수를 minItems == maxItems로 설정해 모델이 반드시 지정된 개수만큼 객체를 생성하도록 물리적으로 강제했습니다. 덕분에 제작되는 문제 수를 고정할 수 있었습니다.</p><pre>public class ResponseFormatUtil {<br>    public static ResponseFormat createSelectionMockExamResponseFormat(int minItems, int maxItems) {<br>        // 리스트의 요소 개수를 고정하고 반환 문제 수 강제화<br>        Schema schema = new Schema(&quot;array&quot;, items, minItems, maxItems);<br>        return new ResponseFormat(&quot;json&quot;, schema);<br>    }<br>}</pre><p><strong>적용 후 검증</strong></p><p>JSON 파싱 오류가 완전히 해결되었으며 프롬프트의 형식을 설명하는 지시문이 빠지면서 전체 길이가 <strong>5,096자에서 4,689자로 약 8% 감소</strong>했습니다.</p><p>Structured Outputs는 JSON의 뼈대만 잡아 줄 뿐 문제의 품질(내용적 정확도)은 개선되지 않았습니다. 동일한 문제를 반복하거나 지정된 유형 이외의 문제를 생성하는 논리적 오류는 그대로 남았습니다.</p><p><strong>참고 자료</strong></p><ul><li>HCX 모델별 특징 → <a href="https://guide.ncloud-docs.com/docs/clovastudio-model">https://guide.ncloud-docs.com/docs/clovastudio-model</a></li><li>Structured Outputs 공식 문서 → <a href="https://api.ncloud-docs.com/docs/clovastudio-chatcompletionsv3-so">https://api.ncloud-docs.com/docs/clovastudio-chatcompletionsv3-so</a></li></ul><h4>3.2 Prompt Routing &amp; Post-processing</h4><p>통합 프롬프트가 할루시네이션의 주범이라고 판단해 6가지 유형의 프롬프트를 완전히 분리하는 Prompt Routing 전략을 채택했습니다.</p><p><strong>구현</strong></p><p>1. <strong>Prompt Routing(프롬프트 분리)</strong> → 유형마다 전용 프롬프트를 따로 두도록 설계했습니다. 이제 AI는 문제를 생성할 때 오직 해당 유형의 규칙(평균 1,100~1,400자)만 사용하도록 수정했습니다. 문제를 만들 때도 필요한 유형의 프롬프트만 골라 사용했습니다.</p><pre>@Getter<br>@RequiredArgsConstructor<br>public enum MockExamType {<br>  FIND_CORRECT(TypeCategory.SELECTION, &quot;prompt/mock_exam/find_correct.txt&quot;),<br>  FIND_MATCH(TypeCategory.SELECTION, &quot;prompt/mock_exam/find_match.txt&quot;),<br>  // ... 유형별 전용 프롬프트 경로 매핑<br>}</pre><p>2. <strong>Java 기반의 후처리 (Post-processing)</strong> → FIND_MATCH(보기 조합형) 유형에서 “생성한 정답이 보기 목록에 없는” 오류는 프롬프트 개선만으로는 완벽히 막기 힘들었습니다. 그래서 AI 응답 직후 백엔드 로직에서 직접 오류를 검사하고 수정하는 로직을 추가했습니다.</p><pre>private void postProcessingFindMatch(List&lt;Hcx007MockExamResponse&gt; responseList) {<br>  responseList.stream()<br>      .filter(quiz -&gt; quiz.getOptions() != null &amp;&amp; !quiz.getOptions().contains(quiz.getAnswer()))<br>      .forEach(quiz -&gt; {<br>        // 정답이 보기에 없다면 첫 번째 항목을 정답으로 교체하여 &#39;답 없음&#39; 오류 원천 차단<br>        if (quiz.getOptions().isEmpty()) {<br>          quiz.getOptions().add(quiz.getAnswer());<br>        } else {<br>          quiz.getOptions().set(0, quiz.getAnswer());<br>        }<br>      });<br>  // 보기 내 항목(ㄱ, ㄴ, ㄷ, ㄹ)을 개수와 문자열 순으로 정렬하는 로직 수행<br>}</pre><p><strong>적용 후 검증</strong></p><p>후처리 로직 덕분에 FIND_MATCH 오류가 해결되었습니다. 프롬프트 용량이 단일 대비 <strong>70% 이상 감소</strong>하면서 모델의 이해도가 높아졌고 추론 옵션 없이도 품질이 향상되었습니다.</p><p>그래도 100문제 중 1문제꼴로 FIND_CORRECT와 INCORRECT를 반대로 생성하는 경우가 있었고 입력 데이터 편중 문제는 여전히 해결되지 않았습니다.</p><h4>3.3 Chunking</h4><p>프롬프트 라우팅으로 개별 문제의 품질은 개선됐지만 <strong>사용성</strong> 문제가 남아 있었습니다. AI가 사용자의 입력 데이터 전체를 확인하지 않고 특정 영역에서만 문제를 만들었습니다.</p><p>이 문제를 해결하려고 <strong>RAG(Retrieval-Augmented Generation)</strong> 도입을 검토했습니다. 그런데 RAG는 사용자의 특정 질문에 가장 관련성 높은 정보를 찾는 기술이라 모의고사 생성의 핵심인 무작위 출제와는 거리가 멀었습니다.</p><ul><li>RAG(검색-증강 생성) VS 단순 분할(Chunking) 비교</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LNc51rQi-mBqFn4uYHRFKw.png" /><figcaption>RAG(검색-증강 생성) vs 단순 분할(Chunking) 비교</figcaption></figure><p><strong>구현</strong></p><p>1. <strong>텍스트 분할 로직 (Chunking with Overlap)</strong> → 사용자 입력을 일정한 크기로 분할하되 이전 조각의 끝부분을 다음 조각의 시작 부분에 포함시켜 문맥의 연속성을 확보했습니다.</p><pre>private List&lt;String&gt; chunkText(String text, int chunkSize, int chunkOverlap) {<br>        ...<br>    List&lt;String&gt; chunks = new ArrayList&lt;&gt;();</pre><pre>    int start = 0;<br>    while (start &lt; text.length()) {<br>        // 다음 시작점을 (크기 - 오버랩) 만큼 이동시켜 문맥을 겹치게 함<br>        if (start &gt;= end) break;<br>    }<br>    return chunks;<br>}</pre><p>2. <strong>무작위 추출 및 중복 제거 (Random Selection)</strong> → 20개의 문제를 생성할 때 분할된 조각들 중 하나를 랜덤하게 선택하고 사용이 끝난 조각은 목록에서 삭제(remove)하여 데이터의 전체 범위에서 문제가 골고루 출제되도록 강제했습니다.</p><pre>for (int i = 0; i &lt; DEFAULT_MOCK_EXAM_COUNT; i++) {<br>    // 모든 조각을 한 번씩 다 사용했다면 다시 리셋하여 재사용<br>    if (availableChunks.isEmpty()) {<br>        availableChunks.addAll(allChunks);<br>    }</pre><pre>    // 랜덤하게 한 조각을 선택하여 AI에 전달<br>    int randomIndex = random.nextInt(availableChunks.size());<br>    String selectedChunk = availableChunks.get(randomIndex);<br>    availableChunks.remove(randomIndex); // 사용한 조각은 리스트에서 제거하여 다양성 확보</pre><pre>    // 이후 해당 조각을 기반으로 AI 요청 수행<br>}</pre><p><strong>적용 후 검증</strong></p><p>각 요청이 (유형별 프롬프트 + 작은 텍스트 조각)만 전달받으므로 단일 요청당 프롬프트 용량이 평균 1,800~2,100자로 약 <strong>50~80% 감소</strong>했습니다. 프롬프트가 줄어든 덕분에 추론 옵션 없이도 유형별 논리적 오류가 거의 사라졌고 같은 입력에도 매번 다른 주제의 문제가 생성되었습니다.</p><p>대신 문제를 하나씩 생성하려고 AI를 20번 순차적으로 호출하다 보니 지연 시간이 쌓였습니다. 총 응답 시간은 여전히 1~2분 사이를 기록했습니다.</p><h4>3.4 Async &amp; 병렬 처리</h4><p>Chunking을 도입해 문제의 품질과 다양성은 확보했지만 응답 시간이 길다는 문제가 남아 있었습니다. 문제를 하나씩 순차적으로 생성하다 보니 20문항 기준 총 2~3분이 걸렸습니다. 사용자가 서비스를 이용하기에는 불편한 수준이라고 생각했습니다.</p><p>순차 처리 방식에서는 각 AI 요청의 네트워크 지연 시간이 고스란히 누적됩니다. 특히 PDF 파일 등으로 API 요청 시 OCR로 인한 대기 시간까지 필요하여 전체 응답 시간은 3~4분까지 늘어날 것으로 예상되었습니다.</p><p>그래서 <strong>독립적인 AI 요청을 동시에(Asynchronously) 처리</strong>하면 전체 소요 시간을 가장 오래 걸리는 단일 요청 1개의 시간만큼으로 단축할 수 있다고 판단해 Spring의 @Async와 CompletableFuture를 도입하기로 했습니다.</p><p><strong>구현</strong></p><p>1. <strong>스레드 풀(Thread Pool)</strong> → 작업을 병렬로 처리하려고 시스템 자원을 관리하는 ThreadPoolTaskExecutor를 설정했습니다.</p><pre>@Configuration<br>@EnableAsync(proxyTargetClass = true)<br>public class AsyncConfig {<br>    @Bean(name = &quot;mockExamTaskExecutor&quot;)<br>    public Executor mockExamTaskExecutor() {<br>        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();<br>        executor.setCorePoolSize(10);<br>        executor.setMaxPoolSize(20);<br>        executor.setQueueCapacity(50);<br>        executor.setThreadNamePrefix(&quot;MockExam-Async-&quot;);<br>        executor.initialize();<br>        return executor;<br>    }<br>}</pre><p>• 작업 흐름</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MHhbY6ji5mSmjqn4SMyEXA.png" /><figcaption>스레드 풀 작업 흐름</figcaption></figure><p>1. <strong>CompletableFuture를 활용한 체이닝</strong> → Java 8에서 도입된 CompletableFuture를 활용해 논블로킹 방식으로 진행했습니다.</p><pre>@Override<br>public CreateMemberMockExamResponse execute(CreateMemberMockExamRequest request) {<br>    // 1. 데이터 분할(Chunking)<br>    List&lt;String&gt; chunkList = createChunkList(request.getPlainText());</pre><pre>    // 2. 비동기 작업 생성 및 요청<br>    List&lt;CompletableFuture&lt;CreateMockQuizResponse&gt;&gt; futures = new ArrayList&lt;&gt;();<br>    for (int i = 0; i &lt; totalTasks; i++) {<br>        // 별도 클래스로 분리된 빈(Bean)을 통해 비동기 메소드 호출<br>        CompletableFuture&lt;CreateMockQuizResponse&gt; future =<br>            createMockQuizService.execute(createMockQuizRequest);<br>        futures.add(future);<br>    }</pre><pre>    // 3. 모든 비동기 작업이 끝날 때까지 대기(Join)<br>    CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();</pre><pre>    // 4. 결과 취합 및 후처리<br>    List&lt;Hcx007MockExamResponse&gt; results = joinAsyncMockQuizTasks(futures);<br>    postProcessingFindMatch(results);</pre><pre>    return CreateMemberMockExamResponse.builder().mockExamList(results).build();<br>}</pre><ul><li>supplyAsync → 반환값이 있는 작업을 별도 스레드에서 시작</li><li>thenApply / thenAccept → 작업 완료 후 결과를 변환하거나 소비하는 콜백을 예약</li><li>allOf(...).join() → 모든 비동기 작업이 끝날 때까지 메인 스레드가 신호를 기다리며 결과를 취합</li></ul><p><strong>적용 후 검증</strong></p><p>하단의 마치며 부분에서 확인하겠습니다.</p><h4>3.5 트러블 슈팅 (Spring AOP, 셀프 호출)</h4><p><strong>a. Spring AOP (프록시 타입)</strong></p><pre>***************************<br>APPLICATION FAILED TO START<br>***************************</pre><pre>Description:<br>The bean &#39;createMemberMockExamService&#39; could not be injected because it is a JDK dynamic proxy</pre><pre>The bean is of type &#39;jdk.proxy2.$Proxy160&#39; and implements:<br>    org.quizly.quizly.core.application.BaseService<br>    ...<br>Expected a bean of type &#39;org.quizly.quizly.mock.service.CreateMemberMockExamService&#39;<br>which implements: org.quizly.quizly.core.application.BaseService</pre><p>Spring은 어노테이션(비동기 로직, 트랜잭션 처리 등)을 주입하기 위해 원본 객체를 감싸는 프록시 객체를 생성합니다. (스프링 핵심 원리 — AOP 부분에 자세히 정리해두었습니다.)</p><p>컨트롤러에서 private final CreateMemberMockExamService ...와 같이 구체적인 클래스 타입으로 주입을 요청했지만 Spring 컨테이너에 있던 것은 인터페이스만 구현한 프록시 객체($Proxy160)였습니다. 타입이 전혀 달라 불일치가 발생했습니다.</p><pre>@Configuration<br>@EnableAsync(proxyTargetClass = true) // ✅ CGLIB(클래스 기반) 프록시 사용 강제<br>public class AsyncConfig { ... }</pre><p>최신 Spring Boot의 기본 프록시 방식이고 프로젝트에서 인터페이스를 사용한 목적이 서비스 레이어의 구현 표준화였기 때문에 실제 구현체를 참조하도록 CGLIB(클래스 기반) 프록시를 선택했습니다. proxyTargetClass = true로 설정해 Spring이 인터페이스가 있더라도 원본 클래스를 상속받는 프록시를 생성하도록 했고 이것으로 클래스 타입 주입 문제를 해결했습니다.</p><p><strong>b. 셀프 호출</strong></p><pre>2025-10-23T13:27:55.930 ... : [Async Task START] Task: 1/10 | Thread: http-nio-8080-exec-1<br>2025-10-23T13:28:06.109 ... : [Async Task SUCCESS] Task: 1/10 | Thread: http-nio-8080-exec-1<br>2025-10-23T13:28:06.109 ... : [Async Task START] Task: 2/10 | Thread: http-nio-8080-exec-1</pre><p>모든 Task가 비동기 스레드가 아닌 http-nio-8080-exec-1 스레드에서 순차 실행되고 있었습니다.</p><pre>@Service<br>public class CreateMemberMockExamService implements BaseService&lt;...&gt; {</pre><pre>  @Override<br>  public CreateMemberMockExamResponse execute(...) {<br>    for (int i = 0; i &lt; totalTasks; i++) {<br>        // ❌ 문제 발생: &#39;this&#39;를 통한 내부 호출은 프록시를 타지 않습니다.<br>        CompletableFuture&lt;CreateMockQuizResponse&gt; future = this.createMockQuizAsync(...);<br>        futures.add(future);<br>    }<br>    ...<br>  }</pre><pre>  @Async(&quot;mockExamTaskExecutor&quot;)<br>  public CompletableFuture&lt;CreateMockQuizResponse&gt; createMockQuizAsync(...) {<br>      // AI 호출 로직...<br>  }<br>}</pre><p>클래스 내부에서 this.method()를 호출하면 프록시가 아닌 원본 객체의 메소드를 직접 호출합니다.</p><p>즉 비동기 처리를 맡을 프록시 로직을 완전히 우회해서 실행됩니다.</p><pre>@Service<br>@RequiredArgsConstructor<br>public class CreateMemberMockExamService implements BaseService&lt;...&gt; {<br>  // ✅ 별도 빈으로 분리된 서비스를 주입받아 호출 (프록시를 통하게 됨)<br>  private final CreateMockQuizService createMockQuizService;</pre><pre>  @Override<br>  public CreateMemberMockExamResponse execute(...) {<br>    ...<br>    for (int i = 0; i &lt; totalTasks; i++) {<br>        // ✅ 정상 작동: 프록시 객체의 execute를 호출하므로 AOP가 적용됨<br>        CompletableFuture&lt;CreateMockQuizResponse&gt; future = createMockQuizService.execute(...);<br>        futures.add(future);<br>    }<br>    ...<br>  }<br>}</pre><p>단일 책임 원칙(SRP)을 지키고 프록시 메커니즘을 제대로 활용하려고 비동기 로직만 담당하는 서비스를 따로 분리했습니다. (CreateMemberMockExamService, CreateMockQuizService)</p><h3>4. 마치며</h3><h4>4.1 API 응답 시간</h4><p>5회 연속 테스트(사용자 입력 7000자 + FIND_MATCH, ESSAY) 중 3~5회차의 평균 응답 시간을 기준으로 확인해보겠습니다. 전체 소요 시간의 <strong>86.8%를 제거</strong>(87.62초 →11.55초)했고 응답 속도는 <strong>약 7.6배</strong> 더 빨라졌습니다.</p><p><strong>Chunking 적용 이후 테스트 — 1m 27.62s</strong></p><p>3회차 (1m 21.72s)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sNV83seKsCZq7ZrFK0YC2g.png" /></figure><p>4회차 (1m 38.70s)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1bsmqf8OgHXho21sJi7vHA.png" /></figure><p>5회차 (1m 22.44s)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B0FbG9GsT5B3cxEa9KTWQw.png" /></figure><p><strong>최적화 완료 이후 테스트 값 — 11.55s</strong></p><p>3회차 (13.06s)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DRQeia0f54L5JBsv4c0NXA.png" /></figure><p>4회차 (11.06s)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OLLGimPRLqsv1XNu03ueeg.png" /></figure><p>5회차 (10.55s)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BBLKV6FPoCY8uZSpVKIyGw.png" /></figure><h4>4.2 비용</h4><p>마지막으로 AI API 1회 요청 시 비용 변화를 확인해보겠습니다. HCX-007의 비용은 입력 토큰(1.25원 / 1,000토큰), 출력 토큰 (5원 / 1,000토큰)입니다. 최종 비용을 분석해 보니 최적화 이후 비용이 <strong>12% 상승</strong>했습니다.</p><p><strong>기존 방식</strong></p><ul><li>토큰 사용량 → 입력 5,384 / 출력 6,500</li><li>최종 비용 → (5.384 X 1.25) + (6.5 X 5) = <strong>39.22원</strong></li></ul><p><strong>최적화 방식</strong></p><ul><li>단일 호출당 토큰 → 입력 837 / 출력 670</li><li>단일 호출 비용 → (0.837 X 1.25) + (0.67 X 5) = 4.39원</li><li>총 비용 (10회) → 4.39원 X 10 = <strong>43.9원</strong></li></ul><h4>4.3 관련 PR</h4><p><a href="https://github.com/Quizly-Team/backend/pull/38">refactor(#36): 모의고사 제작 AI chunk, async 도입 by fnzl54 · Pull Request #38 · Quizly-Team/backend</a></p><h4>4.4 프로젝트 링크</h4><p><a href="https://quizly.co.kr/">quizly</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab74ddf3994e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>