해당글은 실제 현업에서 개발하면서 느낀 부분을 gpt랑 질문하며 정리한 글입니다. 할루시네이션이 있을수 있음을 인지 부탁드립니다.

 

 

리액트 방식의 문제점이라고 생각하는 부분

ReAct 방식의 검증된 한계점

  • 반복 횟수 제한과 불완전한 종료
    반복 횟수(max_iterations)를 설정해도 모델이 작업 완료를 인식하지 못하면 의미 없는 중간 결과가 반환되거나, "iteration limit" 오류로 조기에 멈추는 경우가 많다. LLM이 언제 결과를 최종화해야 할지 인지하지 못한 채 계속 추가 도구를 호출하는 현상 역시 대표적 위험이다.
  • 무한 루프 및 환각(Hallucination)
    에이전트가 이미 수행된 도구 결과를 무시하고 반복하거나, 실제로 존재하지 않는 도구를 호출해 자기 내부 대화만 이어가는 현상이 발생한다. 특히 경량 또는 로컬 모델에서 이러한 루프와 환각이 심화되고, 프롬프트 해석 과정의 오류도 흔하다.
  • 토큰 비용 폭증
    Reasoning → Acting → Observation 사이클마다 전체 컨텍스트를 반복적으로 LLM에 입력해야 하므로, 단순 질의 대비 3~5배 이상 토큰을 소모한다. 서비스 환경에서는 이 비용이 빠르게 증폭된다.

슈퍼바이저 패턴의 실전 문제점

  • 컨텍스트 전파의 딜레마
    모든 메시지를 하위 에이전트에 전달하면 정보량과 비용이 급증하고, 요약하면 중요한 문맥이 손실될 뿐 아니라 추가적인 LLM 호출 비용이 발생한다. 병렬로 작동하는 에이전트들 사이에서 컨텍스트 불일치로 인해 중복 작업 또는 모순된 결과가 생길 수 있다.
  • 라우팅 정확도 저하
    에이전트가 늘어날수록 “다음에 어떤 에이전트에게 태스크를 배분”해야 할지 결정 오류가 자주 발생한다. 컨텍스트가 복잡할수록 분배와 추적 관리가 어려워지고, 계층형 슈퍼바이저 도입 시에도 복잡성과 비용이 올라간다.
  • 종료 조건의 불확실성
    슈퍼바이저가 각 작업의 완료 시점을 확실히 판단하기 어렵고, 일부 하위 에이전트의 부분 성공이나 모호한 반환이 전체 플로우의 불안정성을 유발한다.

추가로 알려진 한계

  • 도구 선택 비효율성
    활용 가능한 도구가 많아지면 최적 도구 선택 오류로 불필요한 호출이 늘어나고, 실제 서비스 단위에서 큰 비용 이슈가 된다.
  • LLM 예측 불가능성
    규칙 기반이 아니라 실시간 응답 생성으로, 결과의 정확성과 일관성을 보장하기 어렵고, 특히 자유 입력 환경에서는 이 문제가 심화된다.
  • 관찰성과 디버깅 한계
    이상 결과나 오작동 원인을 효과적으로 추적하거나 복구하는 기능이 부족하다. 버전·상태 관리도 별도 설계가 필요하다.
  • API 불안정성 대응 부족
    외부 시스템 오류, 대기 시간 지연 등 발생 시 자동 복구·재시도 로직이 부족해 운영 설계가 복잡해질 수 있다.
  • 병렬 실행 관리의 어려움
    여러 도구를 동시 호출할 때 결과 동기화, 오류 처리 복잡도가 높고, 순차 실행 기반 구조에서는 병렬화 최적화가 제한적이다.

현실적인 완화 전략

  • 프롬프트 간결화, 프롬프트 캐싱, 컨텍스트 축소 등으로 토큰 비용 절감
  • 단순 작업과 고난이도 작업을 각각 경량/고성능 모델로 분리하는 모델 캐스케이딩
  • 컨텍스트 구조화로 직전 결정만 전달하고 전체 기록은 별도 저장소로 분리하는 방식
  • 각 에이전트의 단일 책임 설계로 혼란 방지 및 효율화
  • 반복 횟수 이외 목표 달성 여부 확인, 특정 도구 호출 후 바로 종료 등 루프 방지 로직 추가
  • 세션 체크포인팅과 재개 기능을 활용해 장기 작업의 운영성과 UX 향상

도메인/예시 없이, 위와 같은 형태로 ReAct 방식 및 슈퍼바이저 에이전트 패턴의 기술적 한계와 실전 대응 전략을 정리할 수 있다.아래는 ReAct 방식 및 멀티에이전트/슈퍼바이저 패턴의 구조적 한계와 실전 이슈를 특정 분야, 제품 이름 없이 정리한 글이다.


ReAct 방식의 검증된 한계점

  • 반복 횟수를 지정해도 모델이 작업 완료를 인지하지 못하면 "중간 결과"나 "iteration limit" 오류가 발생한다. LLM이 최종 결과를 언제 생성해야 하는지 판단하지 못한 채 여러 번 도구 호출을 반복하는 경우도 흔하다.
  • 에이전트가 같은 작업을 반복하거나, 실제로 없는 도구를 호출해서 내부 루프/환각(hallucination)이 발생한다. 경량 모델이나 로컬 모델을 쓸 때 이런 현상이 더 자주 나타난다.
  • Reasoning → Acting → Observation의 반복에서 전체 컨텍스트가 계속 LLM에 전달되어 토큰 비용이 기하급수적으로 커진다. 실제 서비스 환경에서는 단순 질의 대비 3~5배까지 토큰이 발생할 수 있다.

슈퍼바이저 패턴의 실전 문제점

  • 컨텍스트 전파 딜레마로, 에이전트 간에 전체 메시지를 공유할수록 노이즈와 운영 비용이 늘고, 요약하면 중요한 정보가 누락되고 추가 LLM 호출이 필요해진다. 병렬 에이전트 간 컨텍스트 불일치 때문에 중복 작업이나 논리 충돌도 생긴다.
  • 슈퍼바이저가 관리하는 에이전트 수가 많아질수록 다음에 어떤 에이전트를 호출해야 할지 불확실성이 증가한다. 복잡한 컨텍스트에서는 분배/관리의 정확도가 급격히 저하되는 케이스가 많다.
  • 언제 작업이 완료되는지, 어떤 조건에서 플로우를 끝내야 하는지 명확히 판단하기 어렵다. 하위 에이전트가 모호한 결과를 내면 추가 결정이 불안정해진다.

추가로 널리 보고되는 문제점

  • 도구가 늘어나면 최적 선택 오류, 중복 호출 등 운영 비효율성이 심각해진다.
  • LLM은 규칙 기반 소프트웨어와 달리 결과 예측 불가능성이 높으며, 자유 입력과 동적 환경에서는 그 영향이 더욱 커진다.
  • 에이전트의 잘못된 행동이나 결정을 추적/디버깅하는 과정이 부족하다. 상태와 버전 관리 등은 별도 설계가 필요하다.
  • 외부 API가 실패하거나 지연될 때, 재시도/fallback 로직이 부족하며 전체 설계 복잡도가 늘어난다.
  • 여러 도구를 동시에 호출할 때 동기화나 실패 처리가 어려워지고, 순차 실행 기반 구조에서는 병렬 처리에 제한이 많다.

현실적 완화 전략

  • 프롬프트 간결화, 캐싱, RAG 기반 컨텍스트 관리로 토큰 비용을 절감
  • 간단 작업과 복잡 작업을 경량/고성능 모델로 분리하는 모델 캐스케이딩 적용
  • 슈퍼바이저와 하위 에이전트 간에는 이전 결정만 구조화해 전달하고, 전체 기록은 별도 저장소에 집중
  • 각 에이전트에 단일 책임만 부여하여 혼란과 비효율을 방지
  • 반복 횟수·목표 확인·특정 도구 호출 후 즉시 종료 등 명시적 루프 방지 로직 마련
  • 체크포인트 기능과 세션 복원으로 장기 작업·이탈 후 재개를 지원하고 운영성을 높임
 
 
 

 
사실 그래서 rewoo가 프로덕션에는 좀 더 낫지 않나 싶다
 
 

요구사항과 외부 API가 명확히 정의된 도메인 특화 서비스에서는 ReWOO/Plan-and-Execute 방식이 훨씬 합리적이다.

워크플로우 접근이 적합한 이유

도메인 특화성은 범용 챗봇과 달리 명확한 태스크 흐름이 존재하는 서비스의 핵심 장점이다. Anthropic의 공식 가이드도 "tasks with clearly defined workflows should use structured approaches, not open-ended agent loops"라고 명시한다.

토큰 효율성은 서비스 경제성의 생명줄로, ReWOO가 ReAct 대비 64~80% 토큰 절감과 4.4% 정확도 향상을 달성했다는 연구 결과가 있다. HotpotQA 벤치마크에서 ReWOO는 2,000 토큰으로 42.4% 정확도를 달성한 반면, ReAct는 9,795 토큰으로 40.8% 정확도를 기록했다.

통제 가능성은 지적한 대로 핵심 차별점으로, LangGraph의 명시적 그래프 구조는 "even if your LLM tries to go rogue, the graph won't allow it"라는 강제력을 제공한다. 워크플로우는 각 노드의 입출력을 테스트하고 로깅할 수 있어 프로덕션 신뢰성이 훨씬 높다.

병렬 실행은 계획된 작업의 최대 강점으로, 의존성 없는 작업들을 동시에 수행할 수 있다. ReAct는 순차 실행만 가능하지만, ReWOO는 플레이스홀더로 병렬 처리를 구현한다.

Orchestrator-Worker 패턴의 검증된 효과

슈퍼바이저 기반 아키텍처는 실제로 "separate concerns by role"이 프로덕션 안정성의 핵심이라는 Azure와 LangChain의 공식 권장사항이다. 각 전문 에이전트가 단일 책임만 수행하면 디버깅과 최적화가 명확해진다.

컨텍스트 최소화 전략은 하위 에이전트에게 전체 대화가 아닌 구조화된 상태만 전달하는 방식이다. LangGraph의 TypedDict State는 이런 구조를 강제해 "노이즈 없는 컨텍스트"를 보장한다.

계획 취합 노드는 Plan-and-Execute의 Solver 단계에 해당하며, 각 하위 에이전트의 결과를 종합해 최종 응답을 생성한다. 이 단계만 고성능 LLM을 사용하고 나머지는 경량 모델이나 확정적 함수를 쓰면 비용과 품질을 동시에 확보한다.

웰노운 워크플로우 패턴

Orchestrator-Worker Pattern은 중앙 오케스트레이터가 작업을 분해하고 전문 워커에게 배분한 뒤 결과를 취합하는 방식으로, "most useful for tasks requiring structured approach and careful planning"에 해당한다.

Prompt Chaining with Parallelization은 LangChain이 공식 제시한 첫 번째 워크플로우 패턴으로, 단계별 프롬프트를 체인으로 연결하되 독립 작업은 병렬 실행한다.

Evaluator-Optimizer Loop는 생성된 결과를 평가하고 기준 미달 시 재시도하는 패턴으로, 결과물이 제약조건을 만족하지 못하면 다시 검색하는 로직에 적용할 수 있다.

현실적인 한계 인정의 중요성

**"완벽한 답은 못 만들어도 통제 가능"**이라는 표현이 프로덕션의 본질을 정확히 짚었다. 워크플로우는 "보장된 실행 순서"를 제공하지만 각 단계의 LLM 출력 품질은 여전히 확률적이므로, 출력 검증과 fallback 로직이 필수다.

Structured Output Enforcement는 각 노드의 출력을 Pydantic 스키마로 강제해 다음 노드가 항상 예측 가능한 입력을 받도록 하는 기법으로, Anthropic과 OpenAI 공식 가이드에서 강력히 권장한다.

Explicit Planning Transparency는 사용자가 진행 상황을 볼 수 있도록 하는 것으로, 신뢰도와 UX를 동시에 향상시킨다.

구현 시 핵심 권장사항

노드별 책임 명확화는 각 노드가 하나의 도구나 하나의 판단만 수행하도록 설계하는 것으로, 각각 독립적으로 테스트하고 교체할 수 있다.

조건부 라우팅은 LangGraph의 conditional_edges로 구현하며, 상황에 맞는 경로를 선택한다. ReAct의 무한 루프 위험 없이 명확한 분기를 제공한다.

체크포인팅과 재개는 LangGraph의 핵심 기능으로, 사용자가 이탈했다가 나중에 재개할 수 있도록 지원한다.

도구 실패 처리는 ReWOO가 ReAct보다 우수한 영역으로, 계획 단계에서 이미 모든 도구 호출을 명시했으므로 실패 시 재시도나 대체 도구 선택을 체계적으로 수행할 수 있다.

제안한 아키텍처는 "명확한 요구사항 + 정의된 툴 + 전문 에이전트 + 병렬 실행 + 중앙 취합"이라는 Plan-and-Execute의 이상적 사용 케이스이며, 실제 프로덕션 배포 시 토큰 비용과 신뢰성 측면에서 ReAct보다 압도적으로 유리하다.

 
 

 

그래서 정말 리콰이어먼트가 없는 그런 에이전틱한 ai를 만들때에는 리액트 방식이 조금 나을수도 있겠으나...에이전틱ai는 리액트 방식을 넘어서 정말 ai가 발전해야하며, 대부분의 프로덕션에서 목적성이 있는 서비스는 rewoo가 낫지 않을까 싶다.

 
 

이 글은 개인적으로 공부하기 위함이여 gpt를 기반으로 작성하였으니 할루시네이션은 감안하시고 보시기 바랍니다.

 

 

사내 문서를 봇으로 만든다는 가정

 

벡터 데이터베이스 선택

사내 문서(100장, 예상 5만 벡터) 규모에 최적화된 선택입니다.

벡터DBHNSW 지원하이브리드 검색평균 레이턴시 (1M 벡터)QPS (처리량)설치 난이도추천도
Qdrant ✅ (Native) 3.5ms 1,238 쉬움 (Docker) ⭐⭐⭐⭐⭐
Milvus ✅ (Built-in) 8-12ms 890 보통 (K8s) ⭐⭐⭐⭐
pgvector ❌ (외부 구현) 7ms 280 (but 동시 처리 4.4배) 쉬움 (PostgreSQL) ⭐⭐⭐⭐
OpenSearch ✅ (Plugin) 10-15ms 500 어려움 ⭐⭐⭐
Weaviate ✅ (Alpha) 5-8ms 750 보통 ⭐⭐⭐⭐

벡터디비 검색 성능 평가 지표

 

지표 의미 병원 진단 예시 검색시스템 예시 언제 중요한가
Precision (정밀도) 내가 찾았다고 한 것 중 진짜 정답 비율 암이라고 진단한 100명 중 실제 암 환자 90명 = 90% 검색 결과 10개 중 실제 관련 문서 8개 = 80% 잘못된 결과를 보여주면 안 될 때 (의료, 법률)
Recall (재현율) 전체 정답 중 내가 찾아낸 비율 병원에 있는 실제 암 환자 50명 중 40명 발견 = 80% 데이터베이스에 있는 관련 문서 20개 중 12개 검색 = 60% 놓치면 안 되는 정보가 있을 때 (보안, 법규 준수)
F1 Score Precision과 Recall의 조화평균 두 값이 모두 높아야 높은 점수 균형 잡힌 검색 성능 둘 다 중요할 때 (일반적인 검색)
Recall@K 상위 K개 결과에서의 재현율 처음 본 환자 10명 중 발견률 첫 페이지(상위 10개)에 답이 몇 개? 사용자는 첫 페이지만 본다
NDCG@10 순위까지 고려한 품질 중요한 환자를 먼저 진단했는가 가장 관련 높은 문서가 1등인가 순위가 중요할 때

실무 팁: 사내 문서 Q&A 봇은 Recall@10이 가장 중요합니다. 개발자가 질문했을 때 상위 10개 안에 답이 없으면 신뢰를 잃기 때문입니다. Precision은 80% 이상, Recall@10은 90% 이상을 목표로 설정하세요.

Precision vs Recall 트레이드오프

이 둘은 시소 관계입니다. 검색 결과를 많이 보여주면 Recall은 올라가지만(놓치는 게 없음) Precision은 떨어집니다(쓸데없는 것도 섞임). 반대로 확실한 것만 보여주면 Precision은 올라가지만 Recall이 떨어집니다.

text
예시: "Spring Boot 설정 방법" 검색
   - 엄격한 기준 (similarity > 0.9): 2개 반환, 2개 정답 → Precision 100%, Recall 20%
   - 느슨한 기준 (similarity > 0.7): 15개 반환, 10개 정답 → Precision 67%, Recall 100%
   - 적절한 기준 (similarity > 0.8): 8개 반환, 8개 정답 → Precision 100%, Recall 80% ✅

 

 

문맥 vs 단어: 검색 방식 선택

검색 방식은 크게 두 가지로 나뉩니다. 실무에서는 **둘 다 사용(하이브리드)**하는 것이 정답입니다.

구분Lexical Search (단어 기반)Semantic Search (문맥 기반)Hybrid Search (하이브리드)
원리 단어가 정확히 일치하는지 검색 의미가 비슷한지 검색 둘 다 사용해서 결합
알고리즘 BM25, TF-IDF Dense Vector Embedding BM25 + Vector + RRF
장점 빠름 (ms 단위), 정확한 용어 검색 동의어/유의어 이해, 자연어 쿼리 처리 둘의 장점 결합
단점 "로그인"과 "사용자 인증" 못 찾음 "getUserInfo"같은 정확한 함수명 약함 구현 복잡도 증가
속도 매우 빠름 (1-5ms) 보통 (10-30ms) 보통 (15-40ms)
사용 예시 getUserById() 함수 찾기 "사용자 정보 조회하는 방법" 둘 다 커버
개발 문서 적합도 ⭐⭐⭐ (코드 검색) ⭐⭐⭐⭐ (설명 검색) ⭐⭐⭐⭐⭐ (최적)
 

실무 시나리오 비교:

text
사용자 질문: "API 호출 시 401 에러가 나요"
 
Lexical Search (BM25):
   ✅ "401", "API", "에러" 키워드 정확히 매칭
   ❌ "인증 실패", "토큰 만료" 같은 관련 문서 놓침
 
Semantic Search (Vector):
   ✅ "인증 실패", "권한 오류" 같은 의미적으로 유사한 문서 검색
   ❌ "error code 401" 같은 정확한 코드 검색 약함
 
Hybrid Search:
   ✅ 둘 다 찾아서 RRF로 결합 → 최고 성능

언제 어떤 방식을 선택할까?

상황권장 방식이유
API 함수명, 클래스명 검색 Lexical (BM25) UserRepository.findById() 같은 정확한 매칭 필요
개념 설명, 방법 질문 Semantic (Vector) "어떻게 캐시를 구현하나요?" 같은 자연어
에러 코드, 로그 메시지 Lexical (BM25) NullPointerException 같은 정확한 문자열
복합 질문 (코드 + 설명) Hybrid 사내 문서는 대부분 이 케이스
사내 전문 용어 많음 Hybrid + Custom Dictionary "DPMS", "GSMS" 같은 내부 약어
 

핵심 권장사항: 사내 개발 문서는 반드시 하이브리드 검색을 사용하세요. 코드와 설명이 섞여 있어 단일 방식으로는 한계가 있습니다.

 

 

임베딩 모델 비교: 실전 벤치마크

실제 성능 데이터를 기반으로 모델을 비교했습니다.

주요 임베딩 모델 성능 비교표

모델차원MTEB 평균한국어 성능 (F1)문맥 강점단어 강점코드 지원비용추천도
BGE-m3-ko 1024 66.8 0.7456 🥇 ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐⭐ 무료 ⭐⭐⭐⭐⭐
KU-HIAI-ONTHEIT-large-v1.1 1024 65.2 0.7193 🥈 ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐ 무료 ⭐⭐⭐⭐
text-embedding-3-large (OpenAI) 3072→768 64.6 0.6053 ⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐⭐⭐ $$ ⭐⭐⭐⭐
gemini-embedding-001 (Google) 3072→768 66.3 0.65 (추정) ⭐⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐⭐⭐ $ ⭐⭐⭐⭐⭐
text-embedding-3-small (OpenAI) 1536→512 62.3 0.55 (추정) ⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐⭐ $ ⭐⭐⭐⭐
KoE5 1024 64.1 0.7018 🥉 ⭐⭐⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐ 무료 ⭐⭐⭐⭐
Cohere embed-multilingual-v3 1024 62.0 0.3596 ⭐⭐⭐ ⭐⭐ ⭐⭐⭐ $$ ⭐⭐
all-MiniLM-L6-v2 384 56.3 0.40 (추정) ⭐⭐ ⭐⭐⭐ ⭐⭐ 무료 ⭐⭐
 

성능 지표 설명:

  • MTEB 평균: 전세계 표준 벤치마크 (높을수록 좋음)
  • 한국어 성능: AutoRAG 벤치마크 F1 스코어 (1.0이 만점)
  • 비용: 무료 (오픈소스), $ (저렴), $$ (보통)

문맥 강점 vs 단어 강점 모델

분류모델특징사용 시나리오
문맥 특화 BGE-m3-ko, gemini-embedding-001, KU-HIAI-ONTHEIT Long Context (8192 토큰) 지원, 의미 이해 탁월 "이 기능 어떻게 구현하나요?" 같은 자연어 질문
단어 특화 BM25 (sparse), all-MiniLM-L6-v2 정확한 키워드 매칭 "NullPointerException 해결" 같은 정확한 용어
코드 특화 text-embedding-3-large, gemini-embedding-001 코드 블록 학습, 함수 시그니처 이해 getUserById() 함수 검색, 코드 스니펫
균형형 BGE-m3-ko, text-embedding-3-small 문맥과 키워드 모두 준수 일반적인 사내 문서 (텍스트+코드 혼재)
 

실전 예시:

python
# 문맥 강점 모델 (BGE-m3-ko, Gemini)
 
질문: "사용자 정보를 데이터베이스에서 어떻게 가져오나요?"
"UserRepository의 findById() 메서드 사용" 문서 검색 ✅
→ 의미적으로 관련된 "DAO 패턴 설명" 문서도 검색 ✅
 
# 단어 강점 모델 (BM25, MiniLM)
질문: "getUserById 함수"
→ 정확히 "getUserById" 포함된 코드 스니펫 검색 ✅
"사용자 조회 방법" 같은 유사 의미는 놓침 ❌
 
# 하이브리드 (BGE-m3-ko + BM25)
→ 둘 다 찾아서 결합 → 최고 정확도 ⭐⭐⭐⭐⭐

 

 

벡터 차원 크기: 성능 vs 비용 트레이드오프

차원 수는 검색 시스템의 성능, 속도, 비용을 모두 결정합니다.

차원별 장단점 비교

차원 범위대표 모델장점단점메모리 (5만 벡터)검색 속도추천 용도
384 all-MiniLM-L6-v2 매우 빠름, 저비용 의미 표현력 낮음 75MB 3-5ms 테스트, PoC
512-768 text-embedding-3-small (768), gemini-embedding-001 (768) 균형 잡힌 성능, 적절한 비용 - 150MB 5-10ms 사내 문서 최적 
1024 BGE-m3-ko, KoE5, Cohere 높은 정확도, 복잡한 관계 포착 저장/계산 비용 증가 200MB 10-15ms 고품질 검색 필요 시
1536 text-embedding-3-large 매우 높은 정확도 비용/속도 부담 300MB 15-20ms 고급 검색, 대규모 데이터
3072 gemini-embedding-001 (full) 최고 정확도 매우 높은 비용 600MB 30-40ms 연구, 특수 목적

 

차원 축소 (Matryoshka Embeddings)

최신 모델들은 낮은 차원으로 축소해도 성능을 유지합니다.

원본 차원축소 차원성능 유지율저장 비용 절감속도 향상
3072 (gemini) 768 95-98% 75% ↓ 3-4배 ↑
1536 (OpenAI large) 512 93-96% 67% ↓ 2-3배 ↑
1024 (BGE-m3-ko) 768 97-99% 25% ↓ 1.3배 ↑

 

 

인덱스 알고리즘 비교

인덱스원리속도정확도 (Recall)메모리사용 시나리오
HNSW 계층적 그래프 탐색 ⭐⭐⭐⭐⭐ (1-5ms) ⭐⭐⭐⭐⭐ (99%+) 높음 (RAM 필요) 5만 벡터 최적 
IVFFlat 클러스터 기반 검색 ⭐⭐⭐ (10-20ms) ⭐⭐⭐ (90-95%) 보통 100만+ 벡터
IVF-PQ 클러스터 + 압축 ⭐⭐⭐ (10-30ms) ⭐⭐ (85-90%) 낮음 (압축) 대용량 (10M+)
Flat 전체 검색 (brute force) ⭐ (100ms+) ⭐⭐⭐⭐⭐ (100%) 낮음 1만 이하 소량

 


 

벡터 인덱스 알고리즘 상세

벡터 검색의 핵심은 수백만 개 벡터 중에서 가장 유사한 것을 빠르게 찾는 것입니다. 전체 벡터를 하나씩 비교하면 정확하지만 너무 느리므로, 근사 검색(ANN, Approximate Nearest Neighbor) 알고리즘이 필요합니다.

 

HNSW (Hierarchical Navigable Small World)

작동 원리:

HNSW는 고속도로 시스템처럼 작동합니다. 서울에서 부산 가는 길을 찾을 때, 먼저 고속도로(상위 레이어)로 대략적인 방향을 잡고, 목적지 근처에서 국도(중간 레이어), 마지막에 골목길(하위 레이어)로 정확한 위치를 찾는 것과 같습니다.

text
[Layer 2 - 최상위층] 노드 5개 (전체의 1%) - 장거리 연결, 빠른 탐색
[Layer 1 - 중간층] 노드 50개 (전체의 10%) - 중거리 연결
[Layer 0 - 기저층] 노드 500개 (전체 100%) - 단거리 연결, 정밀 검색

구축 과정:

  1. 계층 배정: 새 벡터가 추가될 때 확률적으로 레이어를 결정합니다. 상위 레이어로 갈수록 선택 확률이 낮습니다 (exponential decay).
  2. 연결 생성: 각 레이어에서 가장 가까운 M개의 이웃과 양방향 링크를 만듭니다. M=16이면 각 노드는 최대 16개 이웃과 연결됩니다.
  3. Greedy Search: 새 벡터를 삽입할 때, 상위 레이어에서 시작해 현재 레이어에서 가장 가까운 노드로 이동하고, 더 가까운 노드가 없으면 한 레이어 내려갑니다.

성능 특성:

특성값설명
시간 복잡도 O(log N) 100만 벡터에서도 20번 이하 비교로 검색
공간 복잡도 O(N × M) 각 노드가 M개 링크 저장, 메모리 많이 필요
구축 시간 O(N × log N × M) 실시간 추가 가능, 재구축 불필요
Recall@10 95-99% 거의 정확함
평균 레이턴시 1-5ms 매우 빠름
 

핵심 파라미터:

python
# HNSW 파라미터 설정 가이드
{
    "M": 16-48,              # 각 노드의 연결 수
                             # M=16: 빠르지만 정확도 낮음
                             # M=32: 균형점 (권장)
                             # M=48: 느리지만 정확도 높음
    
    "ef_construction": 100-500,  # 인덱스 구축 시 탐색 깊이
                                 # 높을수록 구축 느리지만 그래프 품질 좋음
                                 # 200-400 권장
    
    "ef_search": 32-128,    # 검색 시 탐색 깊이
                            # 높을수록 정확하지만 느림
                            # 64-128이 실무 최적
}

# 예시: 5만 벡터, 768차원
# M=32, ef_construction=256, ef_search=64
# → Recall@10: 97%, 레이턴시: 3-5ms, 메모리: 500MB

장점과 단점:

장점단점
✅ 가장 빠른 검색 속도 (1-5ms) ❌ 메모리 사용량 높음 (벡터 크기의 2-3배)
✅ 높은 정확도 (Recall 95%+) ❌ 초기 메모리 로딩 시간 필요
✅ 실시간 업데이트 가능 ❌ 대용량(1억+ 벡터)에서 메모리 부족 가능
✅ 하이퍼파라미터 튜닝 간단  
 

실전 사용 시나리오: 사내 문서 5만 벡터는 HNSW의 최적 범위입니다. 16GB RAM으로 충분하며, 100명 동시 접속도 여유롭게 처리합니다.

IVF (Inverted File Index)

작동 원리:

IVF는 도서관의 주제별 서가와 같습니다. 전체 벡터를 K개 클러스터(Voronoi cell)로 나누고, 검색 시 가장 가까운 몇 개 클러스터만 조사합니다.

text
1. 학습 단계 (K-Means 클러스터링):
   100만 벡터 → 1,000개 클러스터로 분할
   각 클러스터에 평균 1,000개 벡터 포함

2. 검색 단계:
   Query 벡터 → 가장 가까운 nprobe=10개 클러스터만 조사
   → 1만 개 벡터만 비교 (100만 개의 1%)

변형: IVF-PQ (Product Quantization):

IVF에 벡터 압축을 추가한 버전입니다. 768차원 벡터를 96개 서브벡터(각 8차원)로 쪼개고, 각 서브벡터를 256개 코드북 중 하나로 대체합니다.

text
원본 벡터: 768차원 × 4바이트 (float32) = 3,072바이트
IVF-PQ 압축: 96 서브벡터 × 1바이트 (uint8) = 96바이트
→ 32배 압축, 메모리 97% 절감!

성능 비교:

인덱스검색 속도정확도 (Recall)메모리구축 시간
HNSW ⭐⭐⭐⭐⭐ 1-5ms ⭐⭐⭐⭐⭐ 99% 높음 (200%) 빠름
IVFFlat ⭐⭐⭐ 10-20ms ⭐⭐⭐ 90-95% 보통 (100%) 매우 빠름
IVF-PQ ⭐⭐⭐ 15-30ms ⭐⭐ 85-90% 낮음 (3-5%) 느림
Flat ⭐ 100ms+ ⭐⭐⭐⭐⭐ 100% 낮음 (100%) 없음
 

핵심 파라미터:

python
# IVFFlat 설정
{
    "nlist": sqrt(N),        # 클러스터 수 (N=벡터 수)
                             # 100만 벡터 → nlist=1,000
                             # 클수록 정확하지만 구축 느림
    
    "nprobe": 10-100,        # 검색 시 조사할 클러스터 수
                             # nprobe=10: 빠르지만 정확도 낮음
                             # nprobe=50: 균형점
                             # nprobe=100: 느리지만 정확
}

# IVF-PQ 추가 설정
{
    "m": 8, 16, 32,          # 서브벡터 수 (768차원이면 m=96)
    "nbits": 8,              # 각 서브벡터를 몇 비트로 표현 (8bit=256 코드북)
}

실전 사용 시나리오: 100만 벡터 이상 대규모이거나, 메모리가 제한적일 때 IVF-PQ를 사용합니다. 5만 벡터 규모에서는 HNSW가 더 효율적입니다.

알고리즘 선택 가이드

데이터 규모메모리 제약정확도 요구추천 인덱스이유
< 1만 무관 100% Flat 전체 검색해도 빠름
1만 ~ 100만 충분 95%+ HNSW 속도와 정확도 최고
1만 ~ 100만 부족 85%+ IVF-PQ 메모리 97% 절감
100만 ~ 1억 충분 90%+ HNSW 분산 구성 필요
100만 ~ 1억 부족 85%+ IVF-PQ 압축으로 RAM 절약
1억+ 충분 90%+ HNSW (분산) 샤딩 필수
1억+ 부족 80%+ IVF-PQ + SQ 극한 압축

 

 

유사도 측정 방식

벡터 간 "가까움"을 측정하는 방법입니다. 어떤 방식을 선택하느냐에 따라 검색 결과가 완전히 달라집니다.

코사인 유사도 (Cosine Similarity)

의미: 두 벡터 사이의 각도를 측정합니다. 값의 크기(magnitude)는 무시하고 방향만 봅니다.

 

범위 -1 ~ +1 (1에 가까울수록 유사)
정규화 자동 정규화 (벡터 크기 무관)
장점 문서 길이에 영향받지 않음
단점 절대적 차이 무시
적합 케이스 텍스트 임베딩, 추천 시스템

 

유클리드 거리 (Euclidean Distance)

 

의미: 두 점 사이의 직선 거리를 측정합니다. 일상생활에서 쓰는 거리 개념과 동일합니다.


범위 0 ~ ∞ (0에 가까울수록 유사)
정규화 정규화 필요 (벡터 크기 영향)
장점 직관적, 절대적 거리 표현
단점 큰 벡터가 거리 지배 (스케일 민감)
적합 케이스 정규화된 벡터, 이미지 임베딩

 

검색 결합 알고리즘 (RRF)

하이브리드 검색에서 여러 검색 결과를 하나로 합치는 방법입니다.

RRF (Reciprocal Rank Fusion) 상세

핵심 아이디어:

"여러 검색 방식에서 모두 상위권에 나온 문서는 진짜 정답일 가능성이 높다"

 


개인적인 궁금증 : 실무에서는 잘모르는 사용자가 질문을 할수도 있음, 그렇게 되면 되게 모호한 단어들이나 표현들을 쓰는데 찰떡같이 알아듣고 서칭하도록 만들어야함

 

모호한 질문 처리 기술

개발자가 "컨테이너가 안 떠요", "클러스터가 이상해요"처럼 모호하게 질문할 때 대응하는 고급 기술들입니다.

1. Query Rewriting (쿼리 재작성)

핵심 아이디어: 사용자의 모호한 질문을 LLM이 명확하고 구체적인 검색 쿼리로 변환합니다. 또한 프롬프트에 이 문서의 범위나 주요 단어들을 명시해줘야함. 그래야 llm이 범위안에서 추측을 할수있음

4가지 핵심 속성:

속성의미예시
Correctness (정확성) 원래 의도 보존 "그거" → "EKS Pod"
Clarity (명확성) 맥락 독립적 "또 안돼" → "EKS Pod가 다시 재시작됨"
Informativeness (정보성) 관련 정보 추가 "에러남" → "EKS Pod CrashLoopBackOff 에러 발생"
Non-redundancy (비중복성) 중복 질문 제거 이전 질문과 겹치지 않게

2. HyDE (Hypothetical Document Embeddings)

핵심 아이디어: 질문을 직접 검색하지 말고, LLM이 가상의 답변을 생성하고, 그 답변으로 검색합니다.

작동 과정:

text
1. 사용자 질문: "컨테이너가 안 떠요"

2. LLM이 가상 답변 생성 (사실 여부 무관):
   "EKS Pod가 시작되지 않는 경우, 다음을 확인하세요:
    1. kubectl describe pod로 이벤트 확인
    2. 이미지 이름과 태그가 올바른지 확인
    3. ImagePullSecrets 설정 확인
    4. 노드의 리소스(CPU/메모리) 충분한지 확인
    5. SecurityContext 권한 문제 확인"

3. 이 가상 답변을 임베딩 → 벡터 검색
   (실제 문서와 어조/구조가 유사함)

4. 검색 결과: "EKS Pod 트러블슈팅 가이드" (정확히 매칭!)

왜 효과적인가?:

방식임베딩 대상특징검색 품질
일반 검색 "컨테이너가 안 떠요" 짧고 모호 ⭐⭐
HyDE "EKS Pod가 시작되지 않는 경우..." (200단어) 길고 구체적, 문서와 유사한 문체 ⭐⭐⭐⭐⭐

언제 HyDE를 사용할까?:

상황HyDE 효과이유
매우 모호한 질문 ("안돼요", "이상해요") ⭐⭐⭐⭐⭐ LLM이 맥락 추론해서 구체화
전문 용어 모르는 질문 ("그 로드밸런서 같은거") ⭐⭐⭐⭐⭐ LLM이 정확한 용어(ALB) 사용
구체적 질문 ("ALB Ingress Controller 설치 방법") ⭐⭐ 오히려 역효과 (원래 질문이 더 정확)
최신 정보 필요 (2025년 신기능) LLM이 구버전 지식으로 생성

3. Multi-Query Retrieval

핵심 아이디어: 하나의 질문을 여러 관점으로 다시 써서, 각각 검색한 후 결합합니다.

즉, 앙상블 기법으로 생각해라

 

 

 

모호한 질문 처리 파이프라인

python
# 통합 파이프라인
def handle_ambiguous_query(user_query, conversation_history):
    # Step 1: 대화 맥락 기반 Query Rewriting
    rewritten = query_rewriter(user_query, conversation_history)
    # "안돼요" → "EKS Pod ImagePullBackOff 에러"
    
    # Step 2: Multi-Query 생성 (3가지 관점)
    multi_queries = generate_multi_queries(rewritten)
    # [증상, 원인, 해결책] 3개 쿼리
    
    # Step 3: HyDE 추가 (모호한 경우만)
    if is_vague(rewritten):
        hyde_doc = generate_hypothetical_doc(rewritten)
        multi_queries.append(hyde_doc)
    
    # Step 4: 각 쿼리로 하이브리드 검색
    all_results = []
    for query in multi_queries:
        # Dense + Sparse 하이브리드
        dense_results = vector_search(query)
        sparse_results = bm25_search(query)
        hybrid_results = rrf_combine(dense_results, sparse_results)
        all_results.append(hybrid_results)
    
    # Step 5: 전체 결과 RRF 결합
    final_results = rrf_combine(all_results)
    
    # Step 6: Reranker로 최종 정렬 (optional)
    reranked = reranker.rerank(rewritten, final_results)
    
    return reranked[:5]  # 상위 5개 문서

 

최종 권장 아키텍처

text
[사용자] "컨테이너가 안떠요"
    ↓
[대화 맥락 분석] 이전 질문 참조
    ↓
[Query Rewriting] "EKS Pod ImagePullBackOff 에러"
    ↓
[Multi-Query 생성]
    ├─ "EKS Pod 이미지 다운로드 실패 증상"
    ├─ "ImagePullBackOff 발생 원인"
    └─ "ECR 인증 및 이미지 Pull 설정 방법"
    ↓
[HyDE] (필요시) 가상 트러블슈팅 가이드 생성
    ↓
[하이브리드 검색 × 4]
    ├─ Dense (gemini-768) + Sparse (BM25) → RRF
    ├─ Dense (gemini-768) + Sparse (BM25) → RRF
    ├─ Dense (gemini-768) + Sparse (BM25) → RRF
    └─ Dense (gemini-768) + Sparse (BM25) → RRF
    ↓
[RRF 전체 결합] 상위 20개
    ↓
[Reranker] (optional) 최종 5개
    ↓
[LLM 답변 생성] Gemini 1.5 Pro
    ↓
[답변 + 출처]

실제 현업에서 개발하는 API는 단순히 GET요청도 있지만 인증 등이 들어가고 복잡한 데이터를 POST로 요청하는 경우가 많은데

과연 LLM을 이용해서 대화형으로 사용자가 부하테스트를 할 수 있게 구현이 가능한지 궁금증이 들어 시작을 했다.

 

문제는 크게 3가지같다.

1. 다양한 데이터를 어떻게 활용하게 할지 ( 예를들어 로그인 api테스트면 여러 ID를 만드는 가입절차까지 스스로 만들게 하는건 어려워보이기 때문에 이미 만들어진 계정을 넘겨줘야 하는데, 어떻게 넘겨줄지)

 

2. 스크립트를 어떻게 전달할 것인가

    - 스크립트 생성까지 llm이 한다면 검증이 필요한데, 검증은 무조건 스모크테스트처럼 부하를 조금이라도 쏴봐야 한다.

    - 기본적인 스크립트를 줄것인가 ( 그럼 왜 이 llm을 이용하는지에 대한 강점을 확실하게 줘야함 )

 

3. API을 알려주면 어떻게 llm이 이해를 하고 스크립트를 짤것인가, 또는 만들어진 스크립트를 활용할 것인가

    - 스웨거 json을 이용해야하나?

 

 

--개인 메모 -----------

FLOW:  사용자 요청 → LLM 스크립트 생성 → 검증 단계 → 실행 → 결과 보고

 

검증 단계에서는:

  • 문법 검사: k6 스크립트의 문법적 오류 확인
  • 안전성 검사: 위험한 코드나 무한 루프 등 확인
  • 테스트 실행 가능성 검사: 필수 파라미터 누락 여부 확인

점진적 실행 접근법

  • 스모크 테스트 먼저 실행: 생성된 스크립트를 먼저 최소한의 VU(1~2개)로 짧은 시간(5-10초) 실행
  • 결과 확인 후 전체 테스트: 스모크 테스트가 성공하면 전체 테스트 실행

템플릿 기반 접근법

  • 완전히 자유로운 스크립트 생성 대신, 검증된 템플릿을 사용하고 LLM은 파라미터만 채우는 방식

피드백 루프 구현 ( 이건 랭그래프로 복잡한 구조가 될 듯 )

  • 사용자 피드백을 통해 스크립트를 개선하는 메커니즘

 

실용적인 구현 방안

위 접근법들을 종합하여 다음과 같은 실용적인 구현을 제안합니다:

  1. 단계적 접근:
    • 1단계: 템플릿 기반 + 파라미터 추출 (안전하게 시작)
    • 2단계: 제한된 자유도의 스크립트 생성 + 검증
    • 3단계: 완전 자유도의 스크립트 생성 + 강력한 검증
  2. 하이브리드 접근법:
    • 핵심 구조는 템플릿 기반으로 유지
    • 동적 부분(페이로드, 검증 로직 등)은 LLM이 생성
    • 생성된 코드는 샌드박스에서 검증 후 통합
  3. 사용자 지식 활용:
    • "이 API는 JWT 인증이 필요해" 같은 사용자 힌트 활용
    • 이전에 성공한 테스트 패턴 재활용
  4. 점진적 학습:
    • 성공한 스크립트를 데이터베이스에 저장
    • 새로운 스크립트 생성 시 유사한 성공 사례 참조

 

 

---결과----

결론적으로 랭그래프 기반으로 웹까지 연결은 했따

다만 로키와 템포 등 어떠한 분석을 계속 이어나가는것에 리액트 에이전트 방식은 좋지 않은것 같음

리액트 에이전트의 단점은, 개인적으로는 다음과 같다. 

1. 통제 불가능 (반복횟수 통제는 가능하지만, 퀄리티 보장 불가)

2. 위와 같은 맥락으로 토큰 비효율

3. 슈퍼바이저 에이전트의 비효율성 ( 서브에이전트들과의 오케스트레이션시 대화 맥락 전달 등 비효율 부분 발생 )

 

차라리 리우방식이 나은듯

최우선 조건 : 사용자의 복잡한 질문,여러 툴을 이용해야해도 완성도 있게 대답해야 한다.

  1. 오케스트레이터 노드: 사용자 입력을 최초로 받아 처리 방향을 결정하는 중앙 제어 장치
  2. 플래닝 노드: 복잡한 작업을 여러 단계로 분해하여 실행 계획을 수립
  3. 전문 에이전트 노드들: 각각 특정 도구나 서비스에 특화된 8개의 에이전트 (그라파나, 로키, 템포, 아르고시디 등)
  4. 밸리데이션 노드: 결과의 완성도와 정확성을 검증
  5. 응답 노드: 최종 결과를 사용자 친화적으로 요약하여 제공

 

보완하면 좋을 만한 부분들:

  • 컨텍스트 관리: 사용자와의 대화가 이어질 때 이전 대화 컨텍스트를 어떻게 유지할지 고려가 필요함. 예를 들어 "그 중에서 메모리 사용량이 가장 높은 것만 보여줘"와 같은 후속 질문에 대응할 수 있어야 함 -> 메모리세이버 등 이용
  • 에이전트 선택 메커니즘: 오케스트레이터가 어떤 에이전트를 호출할지 결정하는 로직이 중요. -> 프롬프트 강화
  • 실패 처리 메커니즘: 특정 에이전트가 실패하거나 정보를 가져오지 못할 경우에 대한 대처 방안이 필요.-> 고민 필요
  • 사용자 피드백 루: 사용자가 결과에 만족하지 못할 경우 시스템이 어떻게 개선 방향을 찾을지에 대한 고려가 필요 -> 고민 필요
  • 병렬 처리: 여러 에이전트를 동시에 실행하여 응답 시간을 단축하는 방법을 고려해 볼 수 있음 -> 멀티 처리 적용
  • 간 결과 제공: 복잡한 질문의 경우 최종 답변까지 시간이 오래 걸릴 수 있으므로, 중간 진행 상황이나 부분 결과를 제공하는 기능이 유용할 수 있음 -> add 메세지를 구현하고 st.session_state를 이용하여 화면에 실시간 출력
  • 에이전트 확장성: 새로운 에이전트를 쉽게 추가할 수 있는 구조인지 확인. 향후 새로운 도구나 서비스를 통합할 필요가 있을 수 있음 -> 고민필요

 

 

 

코드 구현은 차차 할 예정, 랭그래프, 랭체인, 제미나이 예정

MCP서버를 만들기전 시나리오를 수립해보자.

 

k6 Tool 사용 시나리오

  • 특정 API endpoint에 대해 지정된 부하(초당 요청 수, 가상 유저 수, 지속 시간)로 테스트 실행 및 결과 요약
  • 동일 endpoint에 대한 과거 테스트 결과 비교(성능 트렌드, 최대 TPS, 에러율 등)
  • 다양한 HTTP 메소드(GET, POST, PUT, DELETE)별 부하 테스트.
  • 인증이 필요한 API에 대해 토큰 발급 및 헤더 자동 세팅
  • Swagger/OpenAPI 문서를 파싱하여 자동으로 k6 스크립트 생성.
  • 여러 API endpoint를 조합한 시나리오 테스트(사용자 플로우 시뮬레이션).
  • 테스트 실패(에러율 급증, 응답 지연) 시 자동 알림/이슈 생성.

cli나 스크립트 사용

 

 

 

argocd Tool 사용 시나리오

 

  • 배포 실패시 자동으로 로그도 가져와주기. ( 해결 방안 추천도 해주면 좋을것 같음)
  • 배포 자동화
  • 현재 out-of-sync인 app 요청
  • 배포 히스토리 물어보기
  • 전체 pod진단
  • project생성
  • project리스트 검색
  • project기반 검색
  • app생성
  • app검색
/api/v1/applications (GET) 전체 애플리케이션 목록 및 상태 조회
/api/v1/applications/{appName} (GET) 특정 앱의 상세 정보 및 sync 상태 확인
/api/v1/applications?syncStatus=OutOfSync Out-of-sync 상태인 앱 목록 필터링
/api/v1/applications/{appName}/sync (POST) 특정 앱 강제 동기화 트리거
/api/v1/applications/{appName}/operation 앱에 대한 롤백, 중단 등 연산 실행
/api/v1/projects (GET) 프로젝트 단위로 앱 관리
/api/v1/session (POST) 인증 토큰 발급
 

 

 

챗봇에서 가능한 시나리오:

  • "my-app 어플리케이션 지금 sync상태 어때?" → /api/v1/applications/my-app 호출 후 status.sync.status 반환.
  • "지금 out-of-sync인 서비스들 쭉 알려줘" → /api/v1/applications?syncStatus=OutOfSync로 조회.
  • "my-app을 강제로 동기화해줘" → /api/v1/applications/my-app/sync POST.
  • "오늘 배포된 앱 목록 알려줘" → /api/v1/applications?createdAfter=YYYY-MM-DD 등(필터링 지원 시).
  • "특정 앱의 리소스 트리 보여줘" → /api/v1/applications/{appName}/resource-tree.
  • 특정 프로젝트 내 앱의 동기화 상태 집계 및 리포트.

Agentic AI라는게 정말로 가능한 것인가라는 생각이 든다. 

아직까지 챗봇형태로 할루시네이션이 어느정도 발생하여도 용인이 되는 서비스는 충분히 가능해 보인다. 마누스와 같은...

 

하지만 기업이 서비스를 연동하려면 많은 부분들이 필요해 보인다.

가전제품처럼 오작동이 있어서는 안되는 서비스에서는 re-check과정이 타이트하게 들어가야 하는데 LLM 자체가 생성형이기때문에 항상 우리가 생각하는 일관된 답변을 주지 않아서 re-plan과정이 들어갈수밖에 없다. 이럴수록 시간이 늘어나기 때문에 고객 경험 측면에서 좋지 않음. 근데 이 시간을 줄이기 위해서는 단계를 줄이거나 프롬프트를 엄청나게 잘 짜거나, json형식으로 잘 관리해서  LLM으로 검증하는게 아닌 코드기반으로 빠르게 검증을 해야한다.

 

또한 LLM 호출을 타이트하게 제어해야한다. 돈을 무한정 낼 수 없다.

 

멀티 에이전트간 흐름제어가 굉장히 어렵다. 프롬프트만으로는 불가능해 보이며 결국에는 검증코드들이 많이 들어가야 한다. 

 

에이전틱 ai는 결국에 사람처럼 생각하는 사고방식을 가져야한다. 사람이 과거를 기억하고, 할일의 우선순위를 정하고, 할일을 기억하는 등 이러한 과정을 시스템에 녹여내야 하는데,,,,굉장히 어렵다. 

 

또한 단일 워크플로우만 잘 처리하도록 에이전트를 개발하면 안된다. 아쉬운 점은 현재 대부분의 강의들이 이러한 형태뿐이다. 당연히 그럴수밖에 없는게..아직 국내에서 에이전틱 시스템을 해본사람도 극소수일 것이기에...

 

앞으로는 집중할 부분은 "사람처럼 생각하게하기" , "output검증", "보안이나 오작동을 최소화 하기위한 가드레일 기능" 이다.

< 자료 조사 >

사용할 도구 카테고리 : QA, 모니터링, 부하성능테스트, 도큐먼트 RAG, DB모니터링 등

 

# QA관련도구 

1. 정적 코드 분석 도구

   - 소나큐브 : REST API통해 코드 품질 데이터 수집 및 대시보드 시각화

                      CI/CD 파이프라인과도 연동할수도 있음

   - ESLint : 자바스크립트 및 타입스크립트 코드를 린팅하여 코드 스타일 및 품질 관리 가능

                   MCP서버 연결해서 린팅규칙과 결과를 관리할수도 있을것 같음

   - Semgrep : 코드 보안 취약점 및 품질을 찾아주고 이미지화도 가능

                        커스텀 규칙 작정 및 관리기능을 MCP로 제공하면 좋을듯

 

2. 테스트 도구

    - JUnit : MCP서버로 자바기반 어플리케이션 테스트를 자동으로 실행하고 결과를 수집해주는 것으로 가능

    - pytest : 파이썬 코드를 자동화하고 플러그인으로 커스터마이징된 리포트를 제공하도록 개발

 

 

#모니터링 도구

   -  loki : 로그를 수집하고 쿼리로 보여주는 기능으로 cli및 api지원함. 그라파나와 연동이 매우 쉽기 때문에 mcp서버로 자                연어로 질문이 loki 쿼리를 날려서 결과를 찾아주는 등 다양한 시도가 가능해보임. 

               이미 mcp서버가 있어서 참고하기좋음 (https://github.com/tumf/grafana-loki-mcp, https://github.com/scottlepp/loki-mcp)

     

    - tempo : 트레이싱을 모니터링 하게 도와주는 오픈소스이며 이또한 어플리케이션 api에 대한 트레이싱 추적을 사용자에게 자연어로 질문하도록 연동해주면 편리해 보임 , 이것도 mcp서버가 이미 있어서 참고하기 좋음 ( https://github.com/ivelin-web/tempo-mcp-server, https://github.com/kitakou0313/grafana-tempo-mcp )

 

    - grafana : 시각화 오픈소스로 많은 데이터소스들을 지원함, 특히 개발자들이 대시보드 해석 및 알람 규칙 설정등을 어려워하는데 어느정도 편리하게 제공해준다면 리포트 뽑아내기 등 유용한 기능이 많을 것 같음. 여긴 grafana에서 공식 mcp개발중 ( https://github.com/grafana/mcp-grafana )

 

    - prometheus : 메트릭 수집기로 사용되며 타임시리즈 데이터들을 관리하여 패턴찾기 등등 아주 유용한 데이터베이스. 알람등을 제공하면 좋을것 같음. 이것도 mcp들이 있어서 참고하기 좋음 ( https://github.com/loglmhq/mcp-server-prometheus, https://github.com/pab1it0/prometheus-mcp-server )

 

 

 

 

# 부하성능테스트

    - k6 : grafana에서 만든 부하테스트기로 코드베이스로 제공하기 때문에 굉장히 mcp로 만들기 유용해보임. 프로메테우스로 연동이 되기때문에 그라파나로 성능지표 모니터링이 가능, 자연어를 통해 시나리오를 짜고 리포트까지 주는 기능이 있으면 매우 강력한 도구가 될 것 같음. 이것도 mcp가 있음 ( https://github.com/QAInsights/k6-mcp-server )

 

   - locust : 이 솔루션도 k8s시대에 많이 사용되는 부하성능기. 이것도 mcp가 있음 ( https://github.com/QAInsights/locust-mcp-server )

 

 

#  DB모니터링

    - 이부분은 생각이 잘 떠오르지 않음. db에 대한 데이터 푸시, 검색 등을 할것인지 아니면 모니터링이 주목적인지.  모니터링이 주 목적이라 하면 exporter를 통해 prometheus로 데이터를 넣고 이 데이터를 그라파나에서 가지고오면 되는데 그럼 grafana mcp에 합쳐져야할 기능, 데이터에 대한 푸시 등 기능이면 postgre cli 등을 잘 랩핑하면 mcp로 만들수 있음 ( 아래와 같은 사용예시가 좋아보임 https://modulabs.co.kr/community/momos/44/feeds/719 )

maraidb mcp  ( https://github.com/abel9851/mcp-server-mariadb )

 

 

# RAG

RAG는 서칭관련 기능이 좋을것 같음

   - milvus : k8s에 설치하기 매우 편리하여 테스트용도로 사용하기에 좋음. 아래는 rag를 어떻게 mcp로 사용하면 좋을지 usecase ( https://github.com/teddynote-lab/mcp-usecase/tree/main/case1 ), 또한 mcp도 있어서 참고하기 좋음 ( https://github.com/zilliztech/mcp-server-milvus)

AI관련 업무들을 하게되었는데 스스로 나중에 찾아보기 위한 목적으로 기록할 예정이다.

LLM을 이용한 서비스 개발 내용을 주로 다룰 예정이며 AI석,박은 아니기 때문에 전문성은 떨어질 수 있습니다.

대략적인 내용들은

langchain, langraph 등 위주이며 아키텍쳐 관점에서 많이 다룰 예정.

ollama블로그에서는 embedding model이란 아래와 같이 설명하고 있다.

https://ollama.com/blog/embedding-models

 

즉, 고차원 벡터공간에 데이터를 유의미하게 저장하기 위해 변환하는 방식.

ollama기준 REST API, Python, JS로 사용이 가능하다고 한다.

또한 랭체인이나 라마인덱스같은 툴과도 연동이 가능.

 

랭체인에서 소개하는 임베딩모델은 24.10.29 기준 대표적으로 아래와 같다. 

이외에도 더 있는데 https://python.langchain.com/docs/integrations/text_embedding/ 페이지를 참고.

https://python.langchain.com/docs/integrations/text_embedding/

좀 더 알고싶으면 아래 블로그참고, 좋아보인다.

https://www.syncly.kr/blog/what-is-embedding-and-how-to-use

+ Recent posts