13년차의 서버실

서버, 인프라, 홈랩 기술 블로그

[태그:] LLM

  • [AI] 클라우드 환경에서 Ollama 운영 1년 회고: 비용 효율성 및 관리 노하우

    [AI] 클라우드 환경에서 Ollama 운영 1년 회고: 비용 효율성 및 관리 노하우

    안녕하세요, 13년차 서버실 지킴이 ’13년차의 서버실’입니다.

    오늘은 제가 지난 1년간 클라우드 환경에서 Ollama (올라마)를 운영하면서 겪었던 이야기와, 비용 효율성을 높이고 관리 노하우를 쌓았던 경험을 솔직하게 회고해보려 합니다. 로컬 AI 모델을 쉽게 돌릴 수 있게 해주는 Ollama, 처음엔 제 홈랩 서버에만 돌려봤는데, 어느 날 문득 ‘이걸 클라우드에 올려서 더 많은 사람이 쉽게 접근하게 할 수 없을까?’ 하는 생각이 들었거든요. 그렇게 본격적인 삽질이 시작되었습니다.

    결론부터 말씀드리면, 클라우드에서 Ollama를 운영하는 것은 생각보다 훨씬 매력적이지만, ‘비용’이라는 큰 산을 넘어야 했습니다. 저처럼 로컬 AI를 클라우드로 확장하려는 분들께 제 경험이 작은 길잡이가 되었으면 좋겠네요. 제 삽질의 기록, 지금부터 시작합니다!

    Ollama 클라우드 운영은 사용자 접근성과 확장성을 크게 높여줍니다. 위 다이어그램은 기본적인 서비스 흐름을 나타냅니다.

    Ollama, 클라우드에서 왜? (핵심 개념 설명)

    Ollama (올라마)는 Meta의 Llama나 Mistral AI의 Mistral 같은 대규모 언어 모델(LLM)을 개인용 컴퓨터나 서버에서 쉽게 실행할 수 있도록 도와주는 오픈소스 프레임워크입니다. 쉽게 말해, 복잡한 설정 없이 명령어 한 줄로 다양한 AI 모델들을 다운로드받아 바로 실행할 수 있게 해주는 ‘로컬 AI 모델 실행기’라고 생각하시면 됩니다.

    처음에는 제 홈랩 서버 (Home Lab Server)에서 테스트하며 그 편리함에 감탄했죠. 그런데 여기서 한 가지 아쉬움이 생겼어요. 제 홈랩 서버의 GPU 자원으로는 여러 사람이 동시에 다양한 모델을 사용하기 어렵고, 외부에서 접근하는 것도 보안이나 네트워크 설정이 번거로웠거든요. 그래서 자연스럽게 클라우드 환경으로 눈을 돌리게 되었습니다.

    클라우드에서 Ollama를 운영하면 다음과 같은 장점들이 있습니다:

    • 접근성 (Accessibility): 인터넷만 연결되면 언제 어디서든 접속하여 AI 모델을 사용할 수 있습니다.
    • 확장성 (Scalability): 필요할 때만 고성능 GPU 인스턴스를 사용하고, 사용하지 않을 때는 중단하여 비용을 절감할 수 있습니다. (물론 이게 말처럼 쉽지 않았죠… 후술합니다!)
    • 협업 (Collaboration): 팀원들이나 동료들과 같은 AI 환경을 공유하며 작업할 수 있습니다.
    • 성능 (Performance): 홈랩에서 구성하기 어려운 고성능 GPU (예: NVIDIA A100, H100) 자원을 필요한 만큼 빌려 쓸 수 있습니다.

    클라우드 위 Ollama, 실전 구현부터 삽질까지

    클라우드 환경에 Ollama를 설치하는 과정은 크게 다르지 않습니다. 문제는 어떤 클라우드와 어떤 인스턴스를 선택하느냐, 그리고 어떻게 효율적으로 관리하느냐였죠.

    1. 클라우드 프로바이더 선택 및 인스턴스 프로비저닝

    주요 클라우드 서비스인 AWS (Amazon Web Services), GCP (Google Cloud Platform), Azure (Microsoft Azure) 외에도, GPU 인스턴스 비용이 상대적으로 저렴한 Vultr, Hetzner, Lambda Labs 같은 전문 GPU 클라우드 서비스들도 고려 대상이었습니다. 저는 최종적으로 GCP를 선택했습니다. 이미 다른 프로젝트로 사용 중이었고, Preemptible VM (선점형 VM)이라는 옵션이 비용 절감에 정말 큰 도움이 될 거라고 생각했거든요. (물론 선점형 VM은 예상치 못한 종료라는 명확한 트레이드오프가 있습니다.)

    가장 중요한 건 GPU 인스턴스 선택입니다. Ollama는 CPU로도 구동 가능하지만, 제대로 된 성능을 내려면 GPU가 필수더라고요. 최소한 NVIDIA T4 정도는 되어야 Llama 7B 모델을 돌려도 답답함이 덜합니다. 클라우드에서 GPU 인스턴스를 고를 때 제가 고려한 항목들은 다음과 같습니다.

    • GPU 모델: NVIDIA T4, A100, H100 등. 모델별 성능과 비용이 천차만별입니다.
    • VRAM (Video RAM): 모델 크기에 따라 필요한 VRAM이 다릅니다. Llama 7B는 약 8GB, 13B는 16GB 이상을 권장합니다.
    • 가격: 시간당 요금, 온디맨드(On-demand) vs. 스팟(Spot) vs. 예약(Reserved) 인스턴스 옵션.

    제가 주로 사용했던 GCP의 GPU 인스턴스 유형과 비용 효율성을 고려한 선택지를 표로 정리하면 다음과 같습니다.

    항목 고려 사항 Ollama 운영 시 장단점
    클라우드 프로바이더 AWS, GCP, Azure, Vultr, Hetzner 등 GCP: 선점형 VM으로 비용 절감 가능, 이미 사용 중
    Vultr/Hetzner: GPU 가성비 좋음, 인터페이스 직관적
    GPU 모델 NVIDIA T4 (16GB VRAM), A100 (40/80GB VRAM) T4: 가성비 좋은 시작점, 7B 모델에 적합
    A100: 고성능, 여러 모델 동시 운영, 대형 모델에 적합 (비용 높음)
    인스턴스 유형 온디맨드, 스팟(선점형), 예약 인스턴스 스팟/선점형: 비용 효율적이지만, 예고 없이 종료될 수 있음. 개발/테스트용으로 적합.
    온디맨드: 안정적이지만 비용 높음. 프로덕션 환경에 적합.

    2. Ollama 설치 및 기본 설정

    GPU 인스턴스를 프로비저닝하고 SSH로 접속했다면, Ollama 클라우드 운영의 첫 단계인 설치는 정말 간단합니다. 공식 웹사이트에 나와 있는 스크립트를 실행하면 됩니다. 이때 중요한 게 NVIDIA 드라이버가 잘 설치되어 있는지 확인하는 것입니다. 다행히 클라우드에서 제공하는 GPU 인스턴스 이미지에는 대부분 드라이버가 미리 설치되어 있거나, 쉽게 설치할 수 있는 도구를 제공하더라고요.

    
    # Ollama 설치 스크립트 실행
    curl -fsSL https://ollama.com/install.sh | sh
    
    # 설치 확인 및 모델 다운로드 테스트
    # ollama pull llama2 (약 3.8GB)
    # ollama run llama2
    

    저는 여기서 `systemd` (시스템디)를 이용해 Ollama를 서비스로 등록하고 자동 실행되도록 설정했습니다. 이렇게 하면 서버가 재부팅되어도 Ollama가 자동으로 시작되고, 백그라운드에서 안정적으로 실행되죠. 제가 사용했던 간단한 `systemd` unit 파일입니다.

    
    # /etc/systemd/system/ollama.service 파일 생성
    sudo tee /etc/systemd/system/ollama.service > /dev/null <

    Ollama를 서비스로 등록하여 안정적으로 운영하는 systemd 설정 예시입니다. OLLAMA_HOST 환경 변수를 설정하여 외부 접속을 허용하는 것이 중요합니다.

    클라우드 터미널에서 Ollama 설치 후 `ollama run llama2` 실행 모습 또는 `systemctl status ollama` 명령으로 서비스 상태를 확인하는 화면

    Ollama 설치 후, 모델을 다운로드하고 실행하는 모습입니다. systemd로 서비스 등록 후에는 systemctl status ollama 명령으로 서비스 상태를 확인할 수 있습니다.

    3. 외부 접속 및 보안 설정

    Ollama가 클라우드 인스턴스에서 잘 실행되었다면, 이제 외부에서 접근할 수 있도록 네트워크 설정을 해야 합니다. 기본적으로 Ollama는 11434 포트를 사용합니다. 클라우드 콘솔에서 해당 인스턴스의 방화벽 (Firewall) 규칙을 수정하여 11434 포트의 인바운드 (Inbound) 트래픽을 허용해야 합니다. 저는 특정 IP 대역에서만 접근을 허용하거나, VPN을 통해서만 접속하도록 설정하여 기본적인 보안을 강화했습니다.

    또한, Nginx (엔진엑스) 같은 리버스 프록시 (Reverse Proxy)를 앞에 두어 SSL/TLS (HTTPS)를 적용하고, 기본적인 인증 (Basic Authentication)을 추가했습니다. 이렇게 하면 데이터 전송이 암호화되고, 인가된 사용자만 Ollama API에 접근할 수 있게 되거든요.

    ⚠️ 삽질 보고서: 비용 효율성과의 전쟁

    클라우드에서 Ollama를 운영하며 가장 큰 어려움은 역시 비용 관리였습니다. GPU 인스턴스는 시간당 요금이 정말 비싸거든요. 처음에는 '필요할 때만 켜고 끌 수 있겠지!'라고 생각했지만, 현실은 다았습니다.

    • 인스턴스 종료 깜빡: 테스트하다가 깜빡 잊고 GPU 인스턴스를 끄지 않아 다음 달 요금 폭탄을 맞은 적이 한두 번이 아닙니다. 🤯
    • 선점형 VM의 한계: 비용 절감 효과는 좋았지만, 중요한 작업 중에 예고 없이 인스턴스가 종료되는 경우가 생겼어요. 당황스럽긴 했지만, 다행히 Ollama는 스테이트리스(Stateless)하여 모델 파일만 잘 보존하면 큰 문제는 없었습니다. 다만 작업 흐름이 끊기는 건 어쩔 수 없었죠.
    • 모델 용량과 VRAM: 더 큰 모델, 더 많은 모델을 돌리고 싶다는 욕심에 점점 더 비싼 GPU를 찾게 되더라고요. Llama 70B 같은 모델은 A100 GPU 2개 이상을 요구하기도 합니다.

    이런 삽질 경험들을 통해 배운 교훈은 다음과 같습니다.

    1. 명확한 사용 계획 수립: 어떤 모델을, 얼마나 자주, 누가 사용할지 미리 계획해야 합니다.
    2. 자동화된 시작/종료 스크립트: 특정 시간대에만 인스턴스를 켜고 끄는 Cron (크론) 작업이나 클라우드 스케줄러를 활용하는 게 필수입니다. 예를 들어, 퇴근 후에는 자동으로 인스턴스를 종료하고, 출근 전에 다시 시작하는 스크립트를 만들었어요.
    3. 클라우드 알림 설정: 예산 초과 알림, 인스턴스 상태 변경 알림 등을 설정하여 예상치 못한 비용 발생을 방지해야 합니다.
    4. 스팟/선점형 VM 활용: 개발/테스트 환경에서는 적극적으로 스팟/선점형 VM을 사용하되, 중요한 서비스에는 온디맨드 또는 예약 인스턴스를 사용하는 하이브리드 전략을 구사해야 합니다.
    Ollama 클라우드 운영 중 GPU 인스턴스 비용이 막대 그래프로 표시된 가상의 클라우드 비용 관리 대시보드 스크린샷

    클라우드 비용은 방심하면 순식간에 늘어납니다. 위 그림처럼 비용 대시보드를 주기적으로 확인하고 알림을 설정하는 것이 정말 중요합니다.

    1년 회고: Ollama 클라우드 운영의 성과와 배운 점

    지난 1년간 클라우드에서 Ollama를 운영하며 많은 것을 얻었습니다. 무엇보다 로컬 LLM의 가능성을 클라우드 환경에서 마음껏 실험해볼 수 있었다는 점이 가장 컸습니다. 동료들과 함께 필요한 모델을 테스트하고, 간단한 POC (Proof Of Concept, 개념 증명)를 진행하는 데 정말 큰 도움이 되었죠.

    가장 큰 성과는 역시 '자동화된 비용 관리 루틴'을 만들었다는 점입니다. 처음엔 일일이 수동으로 켜고 끄며 허둥댔지만, 지금은 스크립트와 클라우드 스케줄러 덕분에 훨씬 안정적으로 운영하고 있습니다. 예를 들어, GCP의 Cloud Scheduler와 Cloud Functions를 연동하여 특정 시간에 GPU VM을 시작/중지하는 파이프라인을 구축했습니다. 덕분에 불필요하게 낭비되는 비용을 크게 줄일 수 있었죠.

    Ollama 자체도 지난 1년간 빠르게 발전했습니다. API의 안정성이나 모델 지원 범위가 훨씬 넓어져서, 이제는 단순 테스트를 넘어 실제 서비스의 백엔드로 활용할 가능성도 엿보입니다. 다만 여전히 대규모 트래픽 처리나 고가용성 (High Availability) 측면에서는 추가적인 고민과 아키텍처 설계가 필요해 보입니다.

    마무리: 클라우드 Ollama, 당신의 선택은?

    클라우드 환경에서 Ollama를 운영하는 것은 분명 매력적이고 유용한 경험이었습니다. 특히 AI 모델에 대한 접근성을 높이고, 고성능 자원을 유연하게 활용할 수 있다는 점은 홈랩 환경에서는 얻기 어려운 장점입니다.

    그렇다면 어떤 경우에 클라우드 Ollama를 추천할까요?

    • 개인 개발/학습용: 고성능 GPU가 없거나, 외부에서 접근하여 LLM을 사용하고 싶은 개인 개발자에게는 클라우드 스팟/선점형 인스턴스를 활용한 Ollama 운영이 좋은 선택입니다. 비용 효율적으로 다양한 모델을 실험할 수 있거든요.
    • 소규모 팀의 AI 모델 테스트/POC: 여러 팀원이 동일한 환경에서 AI 모델을 테스트하고 싶을 때 유용합니다. 공유된 클라우드 인스턴스에 Ollama를 띄워두고 API로 연동하면 협업 효율을 높일 수 있습니다.
    • 제한적인 프로덕션 환경: 특정 시간대에만 사용량이 몰리거나, 내부 사용자만을 대상으로 하는 서비스라면, 자동화된 시작/종료 로직과 함께 클라우드 Ollama를 활용해 볼 수 있습니다.

    반면, 상시 고가용성이 요구되는 대규모 프로덕션 환경이나, 매우 민감한 데이터를 처리해야 하는 경우에는 Ollama 단독보다는 MLOps (Machine Learning Operations) 파이프라인과 결합하거나, 보다 전문적인 LLM 서빙 솔루션을 고려하는 것이 좋습니다.

    저의 13년차 서버실 경험을 바탕으로 말씀드리자면, '무조건 클라우드가 좋다'거나 '무조건 온프레미스가 좋다'는 답은 없습니다. 각자의 상황과 목적에 맞춰 가장 효율적인 방법을 찾아야 합니다. 클라우드 Ollama 운영은 그 중간 지점에서 훌륭한 대안이 될 수 있다고 생각합니다. 여러분도 자신만의 Ollama 클라우드 활용법을 찾아보시길 바랍니다. 궁금한 점이 있다면 언제든 댓글 남겨주세요. 감사합니다!

    Ollama 클라우드 운영의 핵심 요약 인포그래픽: 비용 효율성, 접근성, 관리 용이성, 확장성을 중심으로 장단점 시각화

    지난 1년간의 Ollama 클라우드 운영 경험을 통해 배운 핵심 요약입니다. 클라우드 환경에서 Ollama를 효율적으로 활용하기 위한 인사이트를 얻으셨기를 바랍니다.

  • [Proxmox] Proxmox LLM Ollama 성능 측정 방법론: 재현 가능한 벤치마크

    [Proxmox] Proxmox LLM Ollama 성능 측정 방법론: 재현 가능한 벤치마크

    Proxmox LLM Ollama 환경에서 LLM 추론 성능 측정 방법론

    Proxmox LLM Ollama 조합으로 홈랩 AI 서버를 굴리다 보면, 제일 먼저 막히는 지점이 성능 자체보다 성능 해석이더라고요. 응답이 느릴 때 GPU 가속 경로가 문제인지, 모델 파일을 읽어오는 스토리지가 문제인지, 아니면 VM의 CPU 배치와 메모리 상태가 흔들리는지 한 번에 안 보입니다. 저도 처음엔 모델만 바꿔 가며 체감으로 판단했는데, 그 방식은 기록이 안 남고 원인 분리도 어렵더라고요. 이 글은 Proxmox + Ollama 조합에서 재현 가능한 LLM 성능 측정 방법을 만드는 데 집중합니다.

    핵심은 단순합니다. 총 응답 시간만 보면 거의 항상 잘못된 결론으로 갑니다. Ollama가 내려주는 load_duration, prompt_eval_duration, eval_duration을 분리하고, 같은 시점의 CPU, 메모리, 디스크, GPU 상태를 같이 봐야 합니다. 홈랩에서는 특히 이 구분이 중요합니다. 같은 하드웨어라도 다른 VM의 백업 작업, 메모리 ballooning, 스토리지 캐시 상태 때문에 결과가 꽤 쉽게 흔들리거든요.

    Proxmox 호스트와 게스트 VM, GPU 패스스루, Ollama API, 모니터링 명령 흐름을 한눈에 보는 구성도입니다.

    왜 Proxmox LLM Ollama 환경은 따로 측정해야 할까요?

    베어메탈에서 잘 나오던 수치가 Proxmox VM에서는 다르게 나오는 이유는 단순히 가상화 오버헤드 한 줄로 끝나지 않습니다. 실제로는 가상화 계층이 병목을 숨기거나 증폭하는 방식이 더 문제예요. 예를 들어 GPU 패스스루가 붙어 있어도 VM의 CPU affinity나 NUMA 배치가 어긋나면 생성 구간이 늘어질 수 있고, 모델 파일이 느린 스토리지에 있으면 첫 호출만 유난히 길어집니다. 이걸 분리하지 않으면 괜히 GPU만 탓하게 됩니다.

    • GPU Passthrough 상태: 장치가 VM에 보이는 것과 실제로 추론 가속에 쓰이는 건 다릅니다.
    • CPU affinity와 NUMA 배치: vCPU가 불리한 코어 배치에 놓이면 토큰 생성 지연이 출렁일 수 있습니다.
    • 스토리지 지연시간: 모델 교체가 잦을수록 첫 로딩 시간이 과장되기 쉽습니다.
    • ballooning, swap, 메모리 압박: 평소엔 티가 안 나다가 긴 프롬프트에서 갑자기 드러납니다.
    • Ollama 메트릭 해석 실수: 로딩 시간과 생성 시간을 한 덩어리로 보면 튜닝 방향이 엇나갑니다.

    제가 기준으로 삼는 문장은 하나입니다. 벤치마크는 순위를 매기는 작업이 아니라, 손해가 나는 구간을 특정하는 작업입니다. 이 관점으로 가면 Proxmox 위 LLM 성능 측정이 훨씬 덜 꼬입니다.

    LLM 성능 측정에서 반드시 분리해야 할 항목

    Ollama는 API 응답에 꽤 유용한 타이밍 필드를 포함합니다. 문제는 이 숫자를 읽는 방식입니다. 저는 최소한 아래 네 축을 분리하지 않으면 비교값으로 잘 안 봅니다.

    항목 의미 이 수치가 커질 때 먼저 볼 것 실무 해석
    load_duration 모델을 메모리로 올리는 시간 스토리지, 모델 상주 여부, 첫 호출 여부 첫 호출만 크면 정상 특성일 수 있지만, 반복 호출에서도 크면 적재가 반복되거나 메모리 압박이 있다는 뜻입니다.
    prompt_eval_duration 입력 프롬프트 토큰 처리 시간 프롬프트 길이, 컨텍스트 길이, CPU 상태 RAG나 긴 시스템 프롬프트를 쓰는 환경에서는 이 값이 체감 대기시간의 큰 비중을 차지할 수 있습니다.
    eval_duration 출력 토큰 생성 시간 GPU 가속, CPU 병목, 모델 크기 토큰/초 계산의 핵심 구간입니다. 장비 비교는 대부분 이 값 중심으로 보는 편이 맞습니다.
    시스템 지표 CPU, 메모리, 디스크, GPU 사용량 vmstat, iostat, nvidia-smi API 숫자만으로는 원인을 못 찍습니다. 같은 시점의 시스템 지표가 있어야 근본 원인을 좁힐 수 있습니다.

    여기서 많이 놓치는 포인트가 하나 있습니다. 짧은 프롬프트에서 빠른 모델이 실제 운영 워크로드에서도 빠르다는 보장은 없습니다. 특히 홈랩에서 RAG를 붙이거나 시스템 프롬프트가 길어지면 prompt_eval_duration이 병목으로 튀어나오는 경우가 적지 않았습니다. 그래서 저는 측정 목적을 먼저 나눕니다. 장비 비교인지, 실제 응답 대기시간 확인인지, GPU 패스스루 검증인지에 따라 봐야 할 값이 달라집니다.

    측정 전에 Proxmox 쪽에서 먼저 고정할 것들

    게스트 VM 안에서만 계측을 정교하게 해도, Proxmox 설정이 흔들리면 결과는 들쭉날쭉해집니다. 측정 전에 아래 조건부터 고정해두는 편이 낫습니다.

    1. 같은 모델 태그, 같은 프롬프트, 같은 출력 길이 조건으로 반복합니다.
    2. 테스트 시간대에는 다른 VM의 백업, 미디어 인덱싱, 대용량 복사 같은 잡음을 줄입니다.
    3. GPU 패스스루를 쓴다면 항상 같은 VM, 같은 게스트 커널 상태에서만 비교합니다.
    4. ballooning target, swap 개입 여부를 먼저 확인하고, 가능하면 벤치 구간에서는 메모리 조건을 고정합니다.
    5. 모델 파일 위치가 로컬 SSD인지, 네트워크 스토리지인지, ZFS ARC나 페이지 캐시 영향이 있는지 기록합니다.

    여기서 실전적으로 중요한 구분이 cold run과 warm run입니다. 첫 요청은 적재 비용이 섞이고, 두 번째부터는 메모리 상주 효과가 붙습니다. 둘을 한 표에 섞어두면 얼핏 데이터가 많아 보여도 해석에는 별 도움이 안 됩니다.

    Proxmox 쪽에서 제가 특히 먼저 확인하는 건 세 가지입니다. CPU affinity, NUMA 사용 여부, ballooning 조건 고정 여부입니다. CPU 배치가 계속 흔들리면 짧은 벤치에서는 티가 덜 나도 반복 측정 편차가 커집니다. ballooning도 운영 효율에는 도움이 되지만, 추론 성능 비교에는 변수로 끼어들 수 있습니다. 홈랩에서는 운영 효율과 벤치 재현성이 종종 충돌하는데, 벤치 시간에는 재현성을 우선하는 편이 낫더라고요.

    실전 구현 1: Ollama API로 응답 시간과 토큰 생성 속도 수집

    CLI 체감은 참고용으로는 괜찮지만, 기록용 벤치마크에는 조금 아쉽습니다. 반복 측정과 후처리를 생각하면 Ollama API의 원본 메트릭을 그대로 저장하는 편이 훨씬 낫습니다. 아래처럼 한 번 호출해서 핵심 필드를 바로 계산해보면 감이 빨리 옵니다.

    curl -s http://127.0.0.1:11434/api/generate \
      -H 'Content-Type: application/json' \
      -d '{
        "model": "llama3:8b",
        "prompt": "Explain the difference between CPU bottleneck and GPU bottleneck in one short paragraph.",
        "stream": false,
        "options": {
          "temperature": 0,
          "num_predict": 128
        }
      }' | jq '{
        model,
        created_at,
        total_duration_ns: .total_duration,
        load_duration_ns: .load_duration,
        prompt_eval_count,
        prompt_eval_duration_ns: .prompt_eval_duration,
        eval_count,
        eval_duration_ns: .eval_duration,
        tokens_per_second: (if .eval_duration > 0 then (.eval_count / (.eval_duration / 1000000000)) else 0 end)
      }'

    여기서 temperature를 0으로 두는 이유는 성능 측정에서 출력 다양성을 줄이기 위해서입니다. num_predict를 고정하는 이유도 같고요. 벤치마크에서 가장 흔한 실수가 출력 길이를 매번 다르게 두는 건데, 그렇게 되면 eval_count가 흔들리고 결국 토큰/초 비교도 흐려집니다.

    반복 측정은 최소 5회 정도는 권합니다. 평균만 보지 말고 최솟값, 최댓값, 편차까지 같이 남겨야 합니다. 홈랩에서는 한 번 빠르게 나온 결과보다 얼마나 덜 흔들리는지가 더 중요할 때가 많거든요.

    for i in 1 2 3 4 5; do
      curl -s http://127.0.0.1:11434/api/generate \
        -H 'Content-Type: application/json' \
        -d '{
          "model": "llama3:8b",
          "prompt": "Write exactly five bullet points about Linux memory pressure.",
          "stream": false,
          "options": {
            "temperature": 0,
            "num_predict": 96
          }
        }' | jq -r --arg run "$i" '[
          $run,
          .created_at,
          .total_duration,
          .load_duration,
          .prompt_eval_count,
          .prompt_eval_duration,
          .eval_count,
          .eval_duration,
          (if .eval_duration > 0 then (.eval_count / (.eval_duration / 1000000000)) else 0 end)
        ] | @csv'
    done >> ollama-bench.csv

    이 CSV 로그는 보기보다 강력합니다. 나중에 VM 설정을 바꿨을 때, 모델 파일 위치를 옮겼을 때, GPU를 교체했을 때 비교 기준이 그대로 남습니다. 저는 이 단계에서 대시보드부터 만들지 않는 편을 권합니다. 원본 로그가 안정적으로 쌓이는 체계가 먼저고, 시각화는 그 다음이더라고요.

    하나 더요. 벤치마크 목적이라면 stream: false를 유지하는 편이 낫습니다. 스트리밍 출력은 체감 속도 확인에는 좋지만, 수집 포맷이 지저분해지고 메트릭 해석이 섞이기 쉽습니다. 체감용 테스트와 기록용 테스트를 분리해두면 나중에 덜 꼬입니다.

    Ollama 벤치마크에서 LLM 성능 측정 지표를 설명하는 이미지

    Ollama API 응답에서 어떤 필드를 뽑아 성능 지표로 쓰는지 설명하는 시각 자료입니다.

    실전 구현 2: 시스템 자원 사용량을 같이 보세요

    Ollama API 숫자만 보면 원인 추정이 자꾸 빗나갑니다. 같은 요청이라도 CPU 압박인지, 디스크 대기인지, GPU가 실제로 일하는지 구분이 안 되기 때문입니다. 저는 최소한 아래 세 축은 같이 봅니다.

    vmstat 1
    
    iostat -xz 1
    
    nvidia-smi dmon -s pucm
    

    읽는 기준은 단순하지만, 해석은 꽤 실전적입니다.

    • vmstat 1: r가 계속 높고 si/so가 움직이면 CPU 경쟁이나 swap 개입을 먼저 의심합니다.
    • iostat -xz 1: 모델 로딩 시점에 await와 %util이 튀면 load_duration 상승과 연결해서 봅니다.
    • nvidia-smi dmon -s pucm: 생성 중에도 GPU 사용률과 메모리 사용량이 거의 반응하지 않으면 GPU 가속 경로를 다시 확인합니다.

    제가 자주 보는 실패 패턴은 이겁니다. GPU는 VM에서 보이는데, 실제 생성 구간에서는 GPU가 거의 일하지 않는 경우예요. 이때는 패스스루 성공과 추론 가속 성공을 분리해서 봐야 합니다. 장치 인식 자체는 성공했지만 드라이버 상태, 메모리 부족, 런타임 제약 때문에 기대한 만큼 가속이 안 붙는 경우가 있습니다. 반대로 GPU 사용률이 높다고 바로 좋은 것도 아닙니다. 메모리 이동 비용이나 CPU 병목이 남아 있으면 eval_duration 개선이 생각보다 작을 수 있습니다.

    재현 가능한 시나리오: cold run과 warm run 분리 측정

    제가 홈랩에서 가장 자주 쓰는 측정 패턴은 cold run과 warm run을 아예 별도 시나리오로 나누는 방식입니다. 같은 모델, 같은 프롬프트여도 첫 요청과 반복 요청은 성격이 다릅니다. 이 둘을 분리하면 적어도 로딩 비용과 생성 비용은 꽤 깔끔하게 갈라집니다.

    1. Ollama 서비스를 재시작하거나 충분히 유휴 상태를 만든 뒤 첫 요청을 보냅니다.
    2. 첫 요청의 load_duration, total_duration을 기록합니다.
    3. 같은 프롬프트를 3~5회 반복하고, 이 구간에서는 eval_duration과 토큰/초를 중심으로 봅니다.
    4. 동시에 vmstat, iostat, nvidia-smi dmon의 변화를 같은 시각 기준으로 맞춰둡니다.

    실제로는 아래처럼 분리 저장해두면 후처리가 편합니다.

    PROMPT='Explain why swap activity can distort LLM benchmark results in a VM.'
    MODEL='llama3:8b'
    
    # cold run
    curl -s http://127.0.0.1:11434/api/generate \
      -H 'Content-Type: application/json' \
      -d "{\"model\":\"${MODEL}\",\"prompt\":\"${PROMPT}\",\"stream\":false,\"options\":{\"temperature\":0,\"num_predict\":120}}" \
      | jq -r '["cold", .total_duration, .load_duration, .prompt_eval_duration, .eval_duration, .eval_count] | @csv' \
      >> bench-split.csv
    
    # warm runs
    for i in 1 2 3; do
      curl -s http://127.0.0.1:11434/api/generate \
        -H 'Content-Type: application/json' \
        -d "{\"model\":\"${MODEL}\",\"prompt\":\"${PROMPT}\",\"stream\":false,\"options\":{\"temperature\":0,\"num_predict\":120}}" \
        | jq -r --arg run "warm-${i}" '[$run, .total_duration, .load_duration, .prompt_eval_duration, .eval_duration, .eval_count] | @csv' \
        >> bench-split.csv
    done

    이 방식의 장점은 단순한데 실용적입니다. 첫 요청만 느리면 적재 비용 성격, 반복 요청도 계속 느리면 생성 경로 병목으로 빠르게 가설을 세울 수 있습니다. 홈랩에서는 이 구분만 제대로 해도 괜히 GPU부터 바꾸는 일을 꽤 줄일 수 있더라고요.

    홈랩 AI 서버에서 Proxmox와 Ollama 벤치마크를 수행하는 터미널 이미지

    cold run과 warm run을 비교하면서 시스템 자원 모니터링을 병행하는 실전 측정 화면 예시입니다.

    VM, LXC, 베어메탈 중 무엇을 기준점으로 삼아야 할까요?

    이 질문은 자주 나오는데, 저는 목적에 따라 답을 다르게 합니다. 무조건 하나가 낫다고 하기보다 무엇을 검증하려는지 먼저 정하는 편이 맞습니다.

    환경 이럴 때 추천 장점 주의할 점
    베어메탈 절대 성능 기준점이 필요할 때 가상화 변수가 적어 기준선 만들기 좋습니다. 실제 운영 환경이 Proxmox라면 결과 이식성이 떨어질 수 있습니다.
    Proxmox VM GPU 패스스루와 재현성 검증이 목적일 때 운영 환경과 같은 조건으로 측정하기 좋습니다. CPU affinity, NUMA, ballooning 같은 변수를 같이 관리해야 합니다.
    LXC 경량화와 운영 편의가 더 중요할 때 리소스 오버헤드가 적고 관리가 가볍습니다. GPU 활용 방식과 권한 구성이 환경에 따라 더 예민할 수 있어, 벤치 기준점으로는 다소 까다롭습니다.

    제 판단 기준은 이렇습니다. 운영도 Proxmox VM에서 할 예정이면 VM에서 잰 수치를 기준으로 삼는 편이 맞습니다. 베어메탈 수치가 더 좋아도 실제 배포 환경과 다르면 의사결정에는 덜 도움이 됩니다. 반대로 이 하드웨어가 어디까지 나오는지 보고 싶다면 베어메탈 기준선을 한 번 찍어두는 게 좋습니다.

    자주 겪는 문제와 해결 방법

    이 부분은 공식 문서만 봐서는 감이 잘 안 오는 영역입니다. 실제로 벤치를 돌리면 아래처럼 삐끗하는 경우가 많습니다.

    1. 프롬프트 길이가 매번 달라서 비교가 무너집니다

    prompt_eval_duration은 입력 길이에 직접 반응합니다. 질문을 바꾸거나 출력 길이를 열어두면, 모델 자체보다 워크로드 차이가 더 크게 반영됩니다. 벤치 프롬프트는 고정, 출력 길이는 num_predict 등으로 제한하는 편이 낫습니다.

    2. 스트리밍 체감 속도를 성능으로 착각합니다

    터미널에 토큰이 빨리 흘러나오면 체감상 빨라 보입니다. 그런데 그건 계측 기준으로는 불안정합니다. 수집용 벤치는 stream: false로 고정하고, 체감 테스트는 별도로 분리하세요. 둘을 섞어두면 나중에 기록이 비교 불가능해집니다.

    3. 디스크 병목이 숨어 있는데 GPU만 의심합니다

    모델을 자주 바꾸며 테스트할 때 특히 그렇습니다. load_duration이 갑자기 커지고 같은 시점 iostat의 await가 치솟는다면, 그건 GPU보다 모델 적재 경로를 먼저 봐야 합니다. 홈랩에서는 NVMe, SATA SSD, 네트워크 스토리지 차이가 생각보다 크게 드러납니다.

    4. Proxmox에서 다른 VM 부하가 끼어듭니다

    백업 작업, 미디어 트랜스코딩, ZFS scrub, 테스트용 쿠버네티스 VM이 동시에 돌면 반복 측정 편차가 커집니다. 이런 경우 평균값보다 분산이 커지는 패턴이 먼저 나타납니다. 숫자가 안 예쁜 게 아니라, 측정 조건이 불안정한 겁니다.

    5. GPU 사용률만 높고 성능 향상은 미미합니다

    이건 대개 GPU 연산 자체보다 CPU 준비 단계, 메모리 이동, 컨텍스트 처리가 먼저 막히는 경우입니다. 그래서 저는 GPU utilization을 목표값으로 보지 않습니다. eval_duration이 실제로 줄었는지를 먼저 확인합니다.

    6. 첫 요청이 계속 느린데 warm run처럼 해석합니다

    메모리 압박이나 unload 정책 때문에 모델이 자주 내려가는 환경에서는 매번 사실상 cold run이 됩니다. 이때는 첫 요청만 느린 건 정상이라고 넘기면 안 됩니다. 반복 호출인데도 load_duration이 매번 크게 잡히는지를 꼭 확인해보세요. 그건 상주 실패일 가능성이 큽니다.

    검증과 결과 해석: 숫자를 어떻게 읽어야 할까요?

    숫자를 예쁘게 정리하는 것보다 중요한 건, 어떤 패턴에서 어떤 결론을 내릴지 미리 정해두는 겁니다. 저는 보통 아래처럼 읽습니다.

    • load_duration만 크다: 모델 적재, 스토리지, 최초 호출 비용을 먼저 봅니다.
    • prompt_eval_duration이 길다: 긴 프롬프트, 큰 컨텍스트, CPU 토큰 처리 경로를 의심합니다.
    • eval_duration이 길다: 실제 생성 성능 문제입니다. GPU 가속 상태, CPU 할당, 모델 크기 적합성을 봐야 합니다.
    • GPU 사용률이 낮고 CPU만 바쁘다: 패스스루 성공 여부보다 실제 추론 가속 경로를 재확인합니다.
    • 반복 측정 편차가 크다: 다른 VM 간섭, 메모리 압박, 백그라운드 I/O를 먼저 정리합니다.

    여기서 중요한 결정 포인트가 있습니다. 무엇을 최적화할지 먼저 정해야 수치 해석이 쉬워집니다. 사용자 체감 첫 응답을 줄이는 게 목표라면 total_duration과 load_duration이 더 중요합니다. 장비 비교가 목적이면 eval_duration과 토큰/초가 핵심이고요. 긴 컨텍스트 운영이 목표라면 prompt_eval_duration이 병목인지부터 봐야 합니다.

    로그 포맷은 거창할 필요 없습니다. 다만 나중에 조건을 복원할 수 있을 만큼은 남겨두는 편이 좋습니다.

    timestamp,host,vm,model,prompt_name,run_type,total_duration,load_duration,prompt_eval_count,prompt_eval_duration,eval_count,eval_duration
    

    이 한 줄이 중요한 이유는 숫자와 환경을 같이 묶어두기 때문입니다. 벤치 결과만 남기고 VM 설정 이력을 빼먹으면 몇 주 뒤에는 왜 빨라졌는지, 왜 느려졌는지 복기가 잘 안 됩니다. 관련해서 Proxmox GPU 패스스루 설정 글이나 Ollama 설치 가이드를 같이 정리해두면 나중에 내부 링크 연결에도 꽤 유용합니다.

    Proxmox Ollama 환경의 LLM 추론 성능 결과를 시각화한 대시보드 이미지

    모델 로딩 시간과 실제 생성 시간을 분리해 해석하는 결과 대시보드 예시입니다.

    운영 팁: 측정 환경을 문서화해야 나중에 안 꼬입니다

    벤치마크는 숫자보다 맥락이 먼저입니다. 특히 홈랩 AI 서버는 장비를 자주 만지게 되니까, 어떤 조건에서 잰 수치인지 생각보다 빨리 잊어버립니다. 최소한 아래 항목은 같이 기록해두는 편이 좋습니다.

    • 모델 이름과 태그
    • 게스트 OS 종류와 커널 상태
    • vCPU 개수, 메모리 크기
    • GPU 패스스루 유무와 장치 종류
    • 모델 파일 저장 위치
    • 테스트 프롬프트 이름
    • cold run인지 warm run인지

    여기서 제 권장 방식은 단순합니다. 설정 변경이 있는 날에는 벤치마크를 다시 찍고, 변경 사유를 한 줄 메모로 남겨두세요. CPU affinity를 바꿨는지, 메모리를 늘렸는지, 모델 저장 위치를 옮겼는지 정도만 적어도 나중에 비교가 됩니다. 숫자만 예쁘게 모아두는 것보다 이게 훨씬 실용적이더라고요.

    FAQ: 현장에서 많이 헷갈리는 부분

    Q. Proxmox LLM 테스트는 VM이 낫나요, LXC가 낫나요?

    GPU 패스스루 검증과 재현성을 우선하면 저는 VM 쪽을 더 자주 씁니다. 운영 편의만 보면 LXC가 가벼울 수 있지만, 벤치 기준점을 만들 때는 변수를 줄이기 쉬운 쪽이 VM이었습니다.

    Q. Ollama 벤치마크는 CLI만으로 충분한가요?

    단발성 확인은 가능합니다. 다만 반복 측정, CSV 저장, 후처리, cold/warm 구분까지 생각하면 API 기반 수집이 훨씬 낫습니다.

    Q. 숫자는 좋은데 체감은 별로입니다

    짧은 프롬프트 위주로만 재면 실제 운영 패턴과 어긋날 수 있습니다. 특히 RAG, 긴 시스템 프롬프트, 멀티턴 대화가 붙으면 prompt_eval_duration 비중이 커집니다. 운영 워크로드와 비슷한 입력으로 다시 재보는 게 맞습니다.

    Q. 토큰/초가 높으면 무조건 좋은 건가요?

    장비 비교에는 유용하지만, 첫 응답 대기시간이 중요한 환경에서는 부족합니다. 사용자가 느끼는 체감은 종종 load_duration과 prompt_eval_duration에 더 크게 좌우됩니다.

    마지막으로: 이런 상황이면 이렇게 고르시면 됩니다

    제가 실제로 추천하는 선택 기준은 아래처럼 명확합니다.

    • 장비 비교가 목적: 같은 프롬프트와 같은 출력 길이로 고정하고 eval_duration과 토큰/초 중심으로 보세요.
    • 첫 응답 체감이 중요: load_duration을 포함한 total_duration을 같이 봐야 합니다. 모델 상주 전략과 스토리지 위치가 더 중요해질 수 있습니다.
    • GPU 튜닝이 목적: Ollama API 결과만 보지 말고 nvidia-smi dmon과 vmstat를 반드시 붙이세요.
    • 운영 전 검증이 목적: CSV 형태로 누적 저장하고, cold run과 warm run을 분리 기록하세요.
    • 결과가 자꾸 흔들린다: 모델을 바꾸기 전에 다른 VM 간섭, ballooning, swap, 스토리지 대기를 먼저 정리하세요.

    조금 더 직설적으로 말하면 이렇습니다. 첫 응답만 느리면 스토리지와 적재 전략부터, 반복 응답도 느리면 CPU/GPU 경로부터, 숫자가 출렁이면 Proxmox 자원 간섭부터 보시면 됩니다. 이 순서가 실제로 가장 덜 돌아가는 편이었습니다.

    제 경험상, Ollama 숫자만 보고 결론 내리면 절반은 빗나가고, Proxmox 호스트와 게스트의 시스템 지표까지 같이 보면 비로소 조정 포인트가 보입니다. Proxmox LLM Ollama 벤치마크는 장비 스펙보다 측정 설계가 더 중요할 때가 많습니다. 한 번만 잘 만들어두면, 그다음부터는 모델 교체든 VM 튜닝이든 훨씬 덜 감으로 움직이게 됩니다.

    Proxmox와 Ollama 기반 GPU 가속 성능 측정 요약 인포그래픽

    Proxmox 기반 Ollama 벤치마크 절차와 해석 기준을 요약한 인포그래픽입니다.

  • [AI] Gemini API 실전 활용 가이드: 멀티모달 기능으로 AI 서비스 구축하기

    Gemini API 실전 활용 가이드: 멀티모달 AI 서비스 구축하기

    안녕하세요, 13년차의 서버실 주인장, 인프라 엔지니어입니다. 요즘 AI 기술 발전 속도가 정말 무섭다는 생각이 들어요. 특히 Gemini API가 등장하면서 텍스트뿐만 아니라 이미지, 오디오, 비디오까지 한 번에 처리하는 멀티모달 AI(Multimodal AI)의 시대가 본격적으로 열렸거든요. 저도 처음엔 ‘이게 정말 될까?’ 싶었는데, 직접 홈랩에서 굴려보니 그 잠재력에 깜짝 놀랐어요. 오늘은 저처럼 새로운 AI 서비스를 구축하고 싶으신 분들을 위해 Gemini API 활용법을 실전 경험 위주로 풀어볼까 합니다. 삽질 과정도 솔직하게 공유할 테니, 여러분은 저보다 더 쉽고 빠르게 목표를 달성하시길 바랍니다! 💡

    그림 1: Gemini API를 활용한 멀티모달 AI 서비스의 개요

    1. Gemini API, 무엇이 그렇게 특별할까요?

    Gemini API는 Google에서 개발한 차세대 대규모 언어 모델(LLM)인 Gemini 모델에 접근할 수 있게 해주는 인터페이스(API)예요. 그런데 단순히 텍스트만 주고받는 LLM과는 결이 다릅니다. 가장 큰 특징은 바로 멀티모달(Multimodal) 기능인데요. 쉽게 말해, 텍스트는 물론이고 이미지, 오디오, 비디오 등 여러 형태의 데이터를 동시에 이해하고 처리할 수 있다는 뜻입니다. 예를 들어, 이미지와 함께 질문을 던지면 이미지를 보고 답변을 해주는 식이죠.

    제가 이 기능을 처음 써봤을 때, ‘와, 이제 AI가 정말 세상을 보는 것 같구나’라는 생각이 들더라고요. 기존에는 이미지를 분석하려면 별도의 이미지 분석 모델을 거쳐야 했는데, Gemini API는 이 모든 걸 한 번에 처리해주니 AI 서비스 구축 과정이 훨씬 간결해졌어요. 특히, Google AI Studio(구 MakerSuite) 같은 도구를 활용하면 코딩 없이도 빠르게 프로토타입을 만들 수 있어서 개발 속도가 확 빨라지는 경험을 했습니다.

    2. Google AI Studio에서 Gemini API 시작하기

    Gemini API 활용의 첫걸음은 API 키를 발급받는 거예요. Google AI Studio에 접속하면 이 과정을 정말 쉽게 진행할 수 있어요. 별도의 복잡한 가입 절차 없이 Google 계정만 있으면 바로 시작할 수 있죠. 저도 처음엔 개발자 콘솔에서 복잡한 과정을 예상했는데, 생각보다 너무 간단해서 놀랐습니다.

    1. Google AI Studio (aistudio.google.com)에 접속합니다.
    2. 좌측 메뉴에서 ‘Get API key’를 클릭합니다.
    3. ‘Create API key in new project’ 또는 ‘Create API key in existing project’를 선택하여 API 키를 발급받습니다.
    4. 발급받은 API 키는 안전한 곳에 보관해야 합니다. 외부에 노출되지 않도록 각별히 주의하세요! ⚠️

    이렇게 API 키를 받았다면, 이제 여러분의 AI 서비스 구축 여정의 절반은 온 거예요. 이 키를 가지고 실제로 API를 호출해볼까요?

    3. Python으로 Gemini API 실전 구현: 멀티모달 챗봇 만들기

    이제 본격적으로 코드를 작성해볼 시간이에요. 저는 주로 Python을 사용해서 API 연동 작업을 하는데요, Gemini API도 Python SDK를 제공해서 정말 편리합니다. 이번 예제에서는 이미지와 텍스트를 동시에 입력받아 답변하는 간단한 멀티모달 챗봇을 만들어보겠습니다.

    3.1. 환경 설정

    먼저 필요한 라이브러리를 설치해야 합니다. 터미널에서 다음 명령어를 실행하세요.

    
    pip install google-generativeai pillow
    

    pillow는 이미지 처리를 위해 필요합니다.

    3.2. API 호출 코드 작성

    다음은 API 키를 설정하고 Gemini API를 호출하는 Python 코드입니다. 저는 보통 .env 파일에 API 키를 저장하고 python-dotenv 라이브러리로 불러오는데, 여기서는 예제 편의상 직접 코드로 넣겠습니다. 실제 운영 환경에서는 환경 변수(Environment Variable)를 사용하는 걸 강력히 권장합니다.

    
    import google.generativeai as genai
    from PIL import Image
    import io
    import os
    
    # 발급받은 API 키를 여기에 입력하세요.
    # 실제 환경에서는 환경 변수를 사용하는 것이 안전합니다.
    GOOGLE_API_KEY = "YOUR_API_KEY"
    genai.configure(api_key=GOOGLE_API_KEY)
    
    # Gemini 2.0 Flash 모델 로드 (멀티모달 기능 지원)
    model = genai.GenerativeModel('gemini-2.0-flash')
    
    def generate_multimodal_response(image_path, text_prompt):
        try:
            # 이미지 파일 로드
            img = Image.open(image_path)
            
            # API에 전달할 콘텐츠 구성
            # 텍스트와 이미지 데이터를 리스트 형태로 전달합니다.
            contents = [
                text_prompt,
                img
            ]
            
            # Gemini API 호출
            response = model.generate_content(contents)
            return response.text
        except Exception as e:
            return f"오류 발생: {e}"
    
    if __name__ == "__main__":
        # 예제 이미지 파일 (실제 이미지 파일 경로로 변경하세요)
        # 저는 홈랩에서 찍은 서버랙 사진으로 테스트해봤어요 ㅎㅎ
        sample_image_path = "./server_rack.jpg" 
        sample_text_prompt = "이 사진에 보이는 것에 대해 설명하고, 특별히 관리해야 할 부분이 있다면 알려줘."
    
        # 이미지 파일이 존재하는지 확인
        if not os.path.exists(sample_image_path):
            print(f"⚠️ {sample_image_path} 파일을 찾을 수 없습니다. 예제 이미지 파일을 준비해주세요.")
        else:
            print(f"질문: {sample_text_prompt}")
            print("이미지와 함께 Gemini API에 요청 중...")
            response_text = generate_multimodal_response(sample_image_path, sample_text_prompt)
            print("\nGemini 답변:")
            print(response_text)
    
    

    이 코드를 실행하려면 server_rack.jpg라는 이미지 파일이 코드와 같은 디렉토리에 있어야 해요. 저는 집에 있는 서버랙 사진을 찍어서 테스트해봤는데, AI가 팬 소음이 크지 않은지, 케이블 정리가 잘 되어 있는지 같은 조언을 해주더라고요. 정말 신기했어요! 🎉

    그림 2: Google AI Studio에서 멀티모달 프롬프트를 테스트하는 모습

    4. 삽질 경험: API Rate Limit과 Token 제한

    제가 Gemini API를 가지고 놀면서 가장 많이 겪었던 삽질은 바로 API Rate Limit(API 호출 제한)과 Token Limit(토큰 제한)이었어요. 처음에는 아무 생각 없이 테스트 스크립트를 여러 번 돌리다가 갑자기 에러를 만나 당황했죠. ⚠️

    • API Rate Limit: 일정 시간 동안 호출할 수 있는 API 요청 횟수 제한입니다. 너무 빠르게 많은 요청을 보내면 ‘Resource Exhausted’ 같은 에러 메시지를 보게 돼요. 저처럼 성격 급한 개발자라면 특히 조심해야 할 부분이에요. 해결책으로는 요청 사이에 time.sleep()을 넣어 딜레이를 주거나, 재시도 로직(Retry Logic)을 구현해서 지수 백오프(Exponential Backoff) 방식으로 요청을 보내는 것이 좋습니다.
    • Token Limit: Gemini 모델이 한 번에 처리할 수 있는 입력(Prompt) 및 출력(Response)의 최대 토큰(Token) 수입니다. 토큰은 단어, 구두점 등 AI가 이해하는 단위라고 생각하시면 돼요. 멀티모달의 경우 이미지도 특정 토큰 양으로 환산됩니다. 너무 긴 텍스트나 고해상도 이미지를 보내면 이 제한에 걸릴 수 있어요. 이럴 땐 입력 텍스트를 요약하거나, 이미지를 압축하여 해상도를 낮추는 등의 방법을 고려해야 합니다.

    이런 제한들은 안정적인 AI 서비스 구축을 위해 반드시 고려해야 할 부분이에요. 무작정 API를 호출하기보다, 각 모델의 제한 사항을 미리 확인하고 설계에 반영하는 습관이 중요합니다. 💡

    5. 결과 확인 및 활용 아이디어

    위 Python 코드를 실행하면 Gemini 모델이 이미지와 텍스트 프롬프트를 기반으로 답변을 생성하는 것을 확인할 수 있습니다. 예를 들어, 서버랙 사진과 함께 질문을 던졌을 때, AI는 사진 속 장비들의 종류를 식별하고, 케이블 정리 상태나 냉각 시스템에 대한 조언을 해줄 수 있어요. 이처럼 멀티모달 AI는 단순한 질문-답변을 넘어 상황 인지 기반의 훨씬 더 유용한 정보를 제공합니다.

    이러한 Gemini API 활용 아이디어는 정말 무궁무진해요.

    • 이미지 기반 제품 추천: 사용자가 찍은 옷 사진을 분석하여 유사한 스타일의 제품을 추천해주는 서비스.
    • 의료 이미지 분석 보조: X-ray나 MRI 이미지와 의사의 소견을 함께 입력하여 진단을 보조하는 시스템 (물론 전문의의 판단이 최우선이겠죠!).
    • 교육 콘텐츠 생성: 학습 자료 이미지와 텍스트를 분석하여 질문을 만들거나 요약본을 생성하는 봇.
    • 스마트 홈 모니터링: CCTV 이미지와 센서 데이터를 결합하여 이상 상황을 감지하고 사용자에게 알림.

    특히 제가 운영하는 홈랩에서는 보안 카메라 영상과 센서 데이터를 연동해서 이상 상황 감지 시스템을 만들어볼까 구상 중이에요. 기존에는 특정 객체 인식만 가능했는데, 이제는 ‘어떤 상황’인지까지 판단할 수 있게 되는 거죠. 정말 기대됩니다! 🎉

    그림 3: Gemini API를 활용한 AI 서비스 아이디어 예시

    6. 마무리하며: 경험이 곧 자산

    오늘은 Gemini API의 멀티모달 기능을 활용하여 AI 서비스 구축하는 방법에 대해 알아봤어요. 저도 처음엔 막막했지만, Google AI Studio를 통해 빠르게 프로토타입을 만들고, Python SDK로 직접 코드를 짜면서 많은 것을 배웠습니다. 특히 멀티모달 AI의 가능성은 상상 이상이었어요.

    물론 API 호출 제한이나 토큰 제한 같은 삽질도 있었지만, 이런 경험들이 쌓여 더 견고하고 효율적인 시스템을 만들 수 있는 밑거름이 된다고 생각해요. 13년차 인프라 엔지니어로서 늘 새로운 기술을 탐구하고 직접 손으로 구현해보는 것이 얼마나 중요한지 다시 한번 느꼈네요. 여러분도 오늘 소개드린 내용을 바탕으로 자신만의 멋진 AI 서비스를 만들어보시길 바랍니다!

    다음 글에서는 Gemini API를 활용한 스트리밍(Streaming) 응답 처리나 함수 호출(Function Calling) 기능에 대해 더 자세히 다뤄볼까 합니다. 관심 있으시다면 다음 포스팅도 기대해주세요! 😉

    그림 4: 13년차 인프라 엔지니어가 홈랩에서 Gemini API를 탐구하는 모습

  • [AI] LangChain RAG 시스템 구축: 임베딩과 검색 증강 생성 실전 가이드

    LLM이 모르는 정보를 물어보면 어떻게 될까요?

    GPT나 Claude 같은 LLM(Large Language Model, 대형 언어 모델)을 써보신 분들은 한 번쯤 이런 경험 있으실 거예요. 회사 내부 문서나 최신 정보를 물어봤더니 “저는 그 정보를 가지고 있지 않습니다”라고 하거나, 아예 그럴싸한 거짓말을 늘어놓는 경우 말이죠. 이게 바로 LLM의 고질적인 한계인 지식 컷오프(Knowledge Cutoff)와 할루시네이션(Hallucination, 환각) 문제입니다.

    저도 처음에 사내 기술 문서 기반 Q&A 시스템을 만들어보려고 했을 때 이 벽에 딱 부딪혔거든요. 그때 찾은 해답이 바로 RAG(Retrieval-Augmented Generation, 검색 증강 생성)였습니다. LangChain RAG 조합을 실제로 구축해보면서 생각보다 강력하다는 걸 느꼈고, 오늘은 그 경험을 처음부터 차근차근 공유해드리려고 합니다.

    이 글은 RAG 시스템을 처음 접하시는 분부터, 개념은 알지만 실제 구현에서 막히는 분들까지 모두 도움이 될 수 있도록 개념 설명부터 실제 코드까지 담았습니다.

    ▲ RAG 시스템의 전체 파이프라인 — 문서 수집부터 임베딩, 벡터 저장소, 검색, 그리고 LLM 응답 생성까지의 흐름

    RAG가 뭔지 쉽게 이해해보기

    검색 증강 생성(RAG)이란?

    쉽게 말해, LLM한테 “오픈북 시험”을 보게 해주는 방식이에요. 기존 LLM은 학습된 데이터만으로 답을 내야 하는 “클로즈드 북” 방식이었다면, RAG는 질문이 들어왔을 때 관련 문서를 먼저 찾아서 LLM에게 “이 자료 참고해서 답해봐”라고 넘겨주는 거거든요.

    RAG의 핵심 흐름은 크게 두 단계로 나뉩니다.

    1. 인덱싱(Indexing) 단계: 문서를 잘게 쪼개고(Chunking), 임베딩(Embedding, 텍스트를 숫자 벡터로 변환)해서 벡터 데이터베이스에 저장
    2. 검색 및 생성(Retrieval & Generation) 단계: 사용자 질문을 임베딩하고, 유사한 문서 조각을 찾아서 LLM에게 컨텍스트로 전달

    임베딩(Embedding)이 RAG의 핵심입니다

    임베딩은 RAG에서 가장 중요한 개념이에요. 텍스트를 수백~수천 차원의 숫자 벡터로 변환하는 건데, 의미가 비슷한 문장은 벡터 공간에서 가까이 위치하게 됩니다. 예를 들어 “강아지”와 “개”는 벡터 공간에서 서로 가깝고, “강아지”와 “자동차”는 멀리 떨어져 있는 식이죠.

    이 거리를 기반으로 질문과 가장 관련 있는 문서 조각을 찾아내는 게 RAG의 검색 로직입니다. 결국 임베딩 품질이 곧 RAG 시스템의 성능을 좌우한다고 봐도 됩니다.

    방식 장점 단점 적합한 상황
    순수 LLM 구현 간단, 빠름 지식 컷오프, 할루시네이션 일반적인 지식 질의
    Fine-tuning 모델 자체가 지식 보유 비용 높음, 업데이트 어려움 특정 도메인 전문화
    RAG 최신 정보 반영, 유연함 검색 품질에 의존 사내 문서, 최신 정보 Q&A

    환경 준비 — 시작 전에 챙겨야 할 것들

    저는 Python 3.11 환경을 기준으로 구성했습니다. 로컬이든 클라우드든 동일하게 적용되는 내용이에요.

    필요한 패키지 설치

    # 가상환경 생성 및 활성화
    python -m venv rag-env
    source rag-env/bin/activate  # Windows: rag-env\Scripts\activate
    
    # 핵심 패키지 설치
    pip install langchain langchain-community langchain-openai
    pip install chromadb  # 벡터 데이터베이스
    pip install tiktoken  # 토큰 카운팅
    pip install pypdf     # PDF 파일 처리
    pip install python-dotenv  # 환경변수 관리

    💡 팁: OpenAI API 대신 로컬 LLM을 쓰고 싶다면 ollama와 langchain-ollama를 추가로 설치하면 됩니다. 이 부분은 다음 글에서 자세히 다룰 예정이에요.

    환경변수 설정

    # .env 파일 생성
    cat > .env << 'EOF'
    OPENAI_API_KEY=sk-your-api-key-here
    EOF

    LangChain RAG 실전 구현 — 단계별 가이드

    이제 진짜 구현 단계입니다. 저는 기술 문서 몇 개를 PDF로 준비해서 테스트했는데요, 예제에서는 텍스트 파일을 기준으로 설명드릴게요. 흐름만 이해하면 PDF든 웹페이지든 동일하게 적용됩니다.

    1단계: 문서 로드(Document Loading)

    from langchain_community.document_loaders import TextLoader, DirectoryLoader
    from langchain_community.document_loaders import PyPDFLoader
    
    # 단일 텍스트 파일 로드
    loader = TextLoader("./docs/my_document.txt", encoding="utf-8")
    documents = loader.load()
    
    # 폴더 내 모든 PDF 파일 로드
    # loader = DirectoryLoader("./docs", glob="**/*.pdf", loader_cls=PyPDFLoader)
    # documents = loader.load()
    
    print(f"로드된 문서 수: {len(documents)}")
    print(f"첫 번째 문서 미리보기: {documents[0].page_content[:200]}")

    2단계: 문서 청킹(Text Splitting)

    문서를 그대로 넣으면 너무 길어서 LLM이 처리하기 어렵거든요. 적당한 크기로 잘라줘야 합니다. chunk_size와 chunk_overlap 설정이 은근히 중요한데, 저도 처음엔 이 값을 어떻게 잡아야 하나 고민 많이 했습니다.

    from langchain.text_splitter import RecursiveCharacterTextSplitter
    
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,      # 각 청크의 최대 문자 수
        chunk_overlap=200,    # 청크 간 겹치는 문자 수 (문맥 연속성 유지)
        length_function=len,
        separators=["\n\n", "\n", " ", ""]  # 분할 우선순위
    )
    
    chunks = text_splitter.split_documents(documents)
    print(f"생성된 청크 수: {len(chunks)}")
    print(f"첫 번째 청크: {chunks[0].page_content}")

    ⚠️ 주의: chunk_overlap을 너무 크게 잡으면 중복 내용이 많아져서 검색 결과가 편향될 수 있어요. 보통 chunk_size의 10~20% 정도가 적당합니다.

    3단계: 임베딩 생성 및 벡터 저장소 구축

    이제 진짜 핵심인 임베딩 단계입니다. 텍스트를 벡터로 변환해서 ChromaDB(로컬 벡터 데이터베이스)에 저장합니다. ChromaDB는 가볍고 설정이 간단해서 개인 프로젝트나 중소 규모 시스템에 딱 맞아요.

    import os
    from dotenv import load_dotenv
    from langchain_openai import OpenAIEmbeddings
    from langchain_community.vectorstores import Chroma
    
    load_dotenv()
    
    # 임베딩 모델 초기화
    embeddings = OpenAIEmbeddings(
        model="text-embedding-3-small"  # 비용 효율적인 임베딩 모델
    )
    
    # 벡터 저장소 생성 (청크를 임베딩해서 저장)
    vectorstore = Chroma.from_documents(
        documents=chunks,
        embedding=embeddings,
        persist_directory="./chroma_db"  # 로컬에 영구 저장
    )
    
    print("✅ 벡터 저장소 생성 완료!")
    print(f"저장된 벡터 수: {vectorstore._collection.count()}")

    ▲ 텍스트 청크가 임베딩 벡터로 변환되어 벡터 데이터베이스에 저장되는 과정 — 유사도 기반 검색의 핵심 메커니즘

    4단계: 검색기(Retriever) 설정

    # 기존에 저장된 벡터 저장소 불러오기 (재시작 시)
    vectorstore = Chroma(
        persist_directory="./chroma_db",
        embedding_function=embeddings
    )
    
    # 검색기 생성 — 질문과 유사한 상위 4개 청크 반환
    retriever = vectorstore.as_retriever(
        search_type="similarity",  # 유사도 기반 검색
        search_kwargs={"k": 4}     # 상위 4개 문서 반환
    )
    
    # 검색 테스트
    test_query = "RAG 시스템의 장점은 무엇인가요?"
    results = retriever.invoke(test_query)
    for i, doc in enumerate(results):
        print(f"\n--- 검색 결과 {i+1} ---")
        print(doc.page_content[:200])

    5단계: RAG 체인(Chain) 완성

    드디어 마지막 단계입니다! 검색기와 LLM을 연결해서 실제로 질문에 답하는 RAG 체인을 만들어볼게요. LangChain의 LCEL(LangChain Expression Language) 문법을 사용하면 복잡한 파이프라인도 간단하게 구성할 수 있습니다.

    from langchain_openai import ChatOpenAI
    from langchain_core.prompts import ChatPromptTemplate
    from langchain_core.runnables import RunnablePassthrough
    from langchain_core.output_parsers import StrOutputParser
    
    # LLM 초기화
    llm = ChatOpenAI(
        model="gpt-4o-mini",
        temperature=0  # 일관된 답변을 위해 temperature를 낮게
    )
    
    # 프롬프트 템플릿 — 이 부분이 RAG 품질을 좌우합니다
    prompt_template = """
    당신은 주어진 컨텍스트를 바탕으로 질문에 답하는 전문 어시스턴트입니다.
    
    컨텍스트:
    {context}
    
    질문: {question}
    
    답변 지침:
    - 반드시 제공된 컨텍스트에 기반하여 답변하세요.
    - 컨텍스트에 없는 내용은 "제공된 문서에서 해당 정보를 찾을 수 없습니다"라고 명시하세요.
    - 명확하고 구체적으로 답변하세요.
    
    답변:
    """
    
    prompt = ChatPromptTemplate.from_template(prompt_template)
    
    # 문서 포맷팅 함수
    def format_docs(docs):
        return "\n\n".join(doc.page_content for doc in docs)
    
    # RAG 체인 구성 (LCEL 방식)
    rag_chain = (
        {
            "context": retriever | format_docs,
            "question": RunnablePassthrough()
        }
        | prompt
        | llm
        | StrOutputParser()
    )
    
    # 실제 질문 테스트
    question = "RAG 시스템에서 임베딩의 역할은 무엇인가요?"
    response = rag_chain.invoke(question)
    
    print("\n🎉 RAG 응답:")
    print(response)

    ⚠️ 삽질 기록 — 실제로 겪었던 문제들

    솔직히 말씀드리면, 처음 구현할 때 꽤 헤맸습니다. 비슷한 상황에서 도움이 될 것 같아서 공유드릴게요.

    문제 1: 한국어 문서 청킹이 이상하게 됨

    영어 문서는 잘 되는데 한국어 문서를 넣었더니 청킹이 이상하게 잘리더라고요. RecursiveCharacterTextSplitter의 기본 separators가 영어 기준이라서 그런 거였어요. 한국어에는 문장 끝 기준을 추가해주면 훨씬 나아집니다.

    # 한국어에 최적화된 청킹 설정
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=800,
        chunk_overlap=150,
        separators=["\n\n", "\n", "。", ".", "! ", "? ", " ", ""]  # 한국어 구분자 추가
    )

    문제 2: 검색 결과가 관련 없는 내용을 가져옴

    질문과 전혀 관련 없는 청크가 상위에 올라오는 경우가 있었는데요. 이때는 MMR(Maximal Marginal Relevance) 검색 방식을 써보세요. 다양성과 관련성을 동시에 고려해줘서 훨씬 나은 결과가 나오더라고요.

    # MMR 방식으로 검색기 설정
    retriever = vectorstore.as_retriever(
        search_type="mmr",
        search_kwargs={
            "k": 4,           # 최종 반환 문서 수
            "fetch_k": 20,    # 후보로 가져올 문서 수
            "lambda_mult": 0.5  # 0: 다양성 최대, 1: 관련성 최대
        }
    )

    문제 3: ChromaDB 재시작 후 데이터 날아감

    처음에 persist_directory를 안 지정했다가 서버 재시작하고 나서 임베딩 데이터가 다 사라졌었어요. 정말 황당했죠. 반드시 영구 저장 경로를 지정하세요. 위 코드에는 이미 반영되어 있으니 그대로 따라하시면 됩니다.

    결과 검증 — 실제로 잘 동작하는지 확인하기

    구현이 끝났으면 제대로 동작하는지 확인해봐야죠. 간단한 평가 코드를 만들어서 테스트해봤습니다.

    # 다양한 질문으로 RAG 시스템 테스트
    test_questions = [
        "문서의 주요 내용을 요약해주세요.",
        "구체적인 설정 방법을 알려주세요.",
        "문서에 없는 내용을 물어보면?"  # 할루시네이션 방지 테스트
    ]
    
    print("=" * 60)
    print("RAG 시스템 검증 테스트")
    print("=" * 60)
    
    for q in test_questions:
        print(f"\n❓ 질문: {q}")
        print("-" * 40)
        
        # 어떤 청크가 검색됐는지도 확인
        retrieved_docs = retriever.invoke(q)
        print(f"📚 검색된 청크 수: {len(retrieved_docs)}")
        
        response = rag_chain.invoke(q)
        print(f"💬 답변: {response}")
        print("=" * 60)

    ▲ RAG 시스템 테스트 결과 화면 — 각 질문에 대해 검색된 청크와 생성된 응답을 확인할 수 있습니다

    세 번째 테스트 질문처럼 문서에 없는 내용을 물어봤을 때, 잘 구성된 RAG 시스템은 "해당 정보를 문서에서 찾을 수 없습니다"라고 답해야 합니다. 이게 안 되면 프롬프트 템플릿을 좀 더 강하게 제약해줘야 해요.

    더 나아가기 — RAG 품질을 높이는 방법들

    기본 RAG는 이제 동작하는데, 실제 프로덕션 환경에서 쓰려면 몇 가지 더 고려해야 할 것들이 있습니다.

    • 청크 크기 최적화: 문서 종류에 따라 최적 chunk_size가 달라요. 코드 문서는 크게, FAQ 형태는 작게
    • Re-ranking(재순위화): 검색된 문서를 다시 한번 관련성 순으로 정렬하는 기법. 검색 품질이 크게 향상됩니다
    • 하이브리드 검색: 벡터 유사도 검색과 키워드 기반 BM25 검색을 함께 사용하면 더 정확해져요
    • 메타데이터 필터링: 문서 출처, 날짜, 카테고리 등 메타데이터를 활용해 검색 범위를 좁힐 수 있습니다
    • 대화 기록 관리: 멀티턴 대화를 위해 ConversationalRetrievalChain 활용 고려

    ▲ 기본 RAG와 고도화된 RAG 파이프라인 비교 — Re-ranking, 하이브리드 검색 등 품질 향상 기법들

    자주 묻는 질문 (FAQ)

    Q. OpenAI API 없이 로컬에서만 RAG를 구축할 수 있나요?

    네, 가능합니다. 임베딩은 sentence-transformers 라이브러리의 오픈소스 모델을, LLM은 Ollama로 로컬 모델을 사용하면 돼요. 비용 없이 완전히 로컬에서 돌릴 수 있어요. 이 부분은 다음 글에서 자세히 다룰 예정입니다.

    Q. 문서가 수만 개인데 ChromaDB로 충분한가요?

    소규모~중규모는 ChromaDB로 충분합니다. 수십만 개 이상의 대규모 문서라면 Pinecone, Weaviate, pgvector 같은 전용 벡터 데이터베이스를 고려해보세요.

    Q. 임베딩 모델을 바꾸면 기존 벡터 데이터도 다시 만들어야 하나요?

    네, 맞습니다. 임베딩 모델이 달라지면 벡터 공간이 달라지기 때문에 기존 데이터를 새 모델로 전부 다시 임베딩해야 합니다. 처음 모델 선택을 신중하게 하는 게 좋아요.

    마무리 — 오늘 배운 것 정리

    오늘 LangChain RAG 시스템을 처음부터 구축해봤는데요, 정리하면 이렇습니다.

    1. 문서를 로드하고 적절한 크기로 청킹
    2. 임베딩 모델로 텍스트를 벡터로 변환해서 벡터 저장소에 저장
    3. 사용자 질문을 임베딩해서 유사 문서 검색
    4. 검색된 문서를 컨텍스트로 LLM에게 전달해서 응답 생성

    처음엔 개념이 복잡해 보여도, 막상 코드로 짜보면 생각보다 직관적이에요. LangChain이 복잡한 파이프라인을 상당히 추상화해줘서 핵심 로직에 집중할 수 있거든요.

    다음 글에서는 OpenAI 없이 Ollama로 완전 로컬 RAG 시스템을 구축하는 방법을 다룰 예정입니다. API 비용 걱정 없이 사내 문서를 분석하고 싶으신 분들께 도움이 될 거예요. 궁금하신 점은 댓글로 남겨주세요! 🎉

  • [AI] RAG 실전 구현 가이드: LLM 환각 현상 줄이고 최신 정보 활용하기

    [AI] RAG 실전 구현 가이드: LLM 환각 현상 줄이고 최신 정보 활용하기

    RAG 실전 구현 가이드: LLM 환각 현상 줄이고 최신 정보 활용하기

    안녕하세요, 13년차 서버실의 인프라 엔지니어입니다. 요즘 인공지능(AI) 분야는 정말 눈 깜짝할 사이에 발전하고 있죠. 특히 대규모 언어 모델(Large Language Model, LLM)은 놀라운 성능으로 우리의 삶과 업무 방식을 바꾸고 있습니다. 그런데 말입니다. 아무리 똑똑한 LLM이라도 가끔은 엉뚱한 소리를 하거나, 오래된 정보만을 바탕으로 답변할 때가 있어요. 일명 LLM의 환각(Hallucination) 현상인데요. 혹시 이런 경험, 직접 해보신 적 있으신가요?

    저도 홈랩에서 LLM을 이것저것 만져보면서 느낀 건데, 최신 정보를 반영하거나 특정 도메인의 깊이 있는 지식을 묻기에는 한계가 명확하더라고요. 마치 최신 뉴스를 전혀 모르는 옛날 사람에게 질문하는 느낌이랄까요? 그래서 오늘은 이 문제를 해결하고 LLM의 답변 정확도를 높이는 Retrieval Augmented Generation(RAG) 기술을 직접 구현해보는 가이드를 준비했습니다.

    RAG는 LLM이 답변을 생성하기 전에 외부 지식 소스에서 관련 정보를 검색하여 이를 바탕으로 답변하도록 하는 기술이에요. 쉽게 말해, LLM에게 “책을 보고 답하세요!”라고 가이드하는 것과 같죠. 이 글을 통해 RAG가 뭔지, 왜 필요한지, 그리고 LangChain과 벡터 데이터베이스를 활용하여 어떻게 실전 구현하는지 단계별로 알아보겠습니다. 자, 그럼 시작해 볼까요?

    RAG 시스템의 전체적인 흐름을 보여주는 아키텍처 다이어그램입니다.

    1. LLM 환각 현상, 왜 발생할까요? 그리고 RAG가 답입니다!

    LLM은 방대한 텍스트 데이터를 학습하여 언어 패턴을 익히고 이를 기반으로 텍스트를 생성합니다. 하지만 학습 데이터는 특정 시점에 고정되기 때문에 최신 정보를 알지 못하죠. 또한, 학습 데이터에 없는 특정 분야의 전문 지식이나 개인화된 정보에 대한 답변은 어렵습니다. 이러한 문제들이 복합적으로 작용하여 LLM의 환각 현상이 발생하게 됩니다.

    환각 현상(Hallucination)은 LLM이 사실이 아니거나 학습 데이터에 근거하지 않은 정보를 마치 사실인 것처럼 그럴듯하게 만들어내는 현상을 뜻해요. 예를 들어, 존재하지 않는 논문을 인용하거나, 잘못된 통계를 제시하는 식이죠. 이는 LLM의 신뢰도를 크게 떨어뜨리는 요인이 됩니다.

    여기서 Retrieval Augmented Generation(RAG)이 등장합니다. RAG는 LLM의 이러한 한계를 극복하기 위한 강력한 솔루션이에요. RAG는 다음과 같은 두 가지 핵심 과정을 통해 작동합니다:

    • Retrieval (검색): 사용자의 질문과 관련된 정보를 외부 지식 소스(문서, 데이터베이스 등)에서 검색합니다.
    • Augmentation (증강): 검색된 정보를 사용자의 질문과 함께 LLM의 입력(프롬프트)으로 제공합니다.

    LLM은 이렇게 제공된 문맥(Context)을 바탕으로 답변을 생성하기 때문에, 훨씬 더 정확하고 최신 정보를 반영한 답변을 할 수 있게 되죠. 마치 똑똑한 AI 비서에게 필요한 자료를 미리 찾아주고 질문하는 것과 같다고 생각하시면 됩니다. 🎉

    2. RAG 구현을 위한 핵심 요소: LangChain과 벡터 데이터베이스

    RAG 시스템을 구축하기 위해서는 몇 가지 핵심 기술 요소가 필요해요. 제가 이번에 사용해 본 툴들은 다음과 같습니다.

    • LangChain: LLM 애플리케이션 개발을 위한 프레임워크예요. LLM과의 연동, 데이터 처리, 외부 도구 연결 등을 쉽게 할 수 있도록 다양한 모듈과 추상화를 제공합니다. RAG 파이프라인 구축에 필수적인 역할을 하죠.
    • 벡터 데이터베이스 (Vector Database): 텍스트 데이터를 벡터(수치형 배열)로 변환하여 저장하고, 유사도 검색을 효율적으로 수행하는 데이터베이스예요. LangChain RAG의 ‘Retrieval’ 단계에서 질문과 관련된 문서를 빠르게 찾아오는 데 핵심적인 역할을 합니다. ChromaDB, FAISS, Pinecone 등이 대표적인데, 저는 이번에 ChromaDB를 사용해봤어요. 설치와 사용이 정말 간편하더라고요.
    • 임베딩 모델 (Embedding Model): 텍스트를 벡터로 변환하는 역할을 해요. OpenAI의 text-embedding-ada-002나 Hugging Face의 다양한 오픈소스 모델 등을 사용할 수 있습니다.

    이 요소들을 조합하면 RAG 파이프라인을 효과적으로 구축할 수 있어요. LangChain은 이러한 각 구성 요소를 연결하고 조율하는 역할을 담당하며, 벡터 데이터베이스는 방대한 지식 소스에서 필요한 정보를 신속하게 찾아오는 ‘창고’ 역할을 하는 셈이죠.

    LangChain을 이용하여 ChromaDB와 LLM을 연결하는 RAG 파이프라인의 구성도입니다.

    3. RAG 실전 구현: 단계별 가이드 (Python & LangChain)

    이제 실제로 LLM RAG 시스템을 구현해 봅시다. 저는 개인적으로 자주 사용하는 Python 환경에서 LangChain 라이브러리를 이용할 예정입니다. 몇 가지 예제 문서를 준비해서 진행해 볼 테니까요. (실제로는 여러분의 문서나 데이터를 사용하시면 됩니다.)

    3.1. 필요한 라이브러리 설치

    먼저 필요한 라이브러리들을 설치합니다. 저는 langchain, chromadb, openai (API 키가 필요합니다), tiktoken 등을 사용해요.

    pip install langchain openai chromadb tiktoken python-dotenv
    

    3.2. 환경 설정 (API 키 로드)

    OpenAI API 키를 환경 변수로 설정하는 게 안전합니다. .env 파일을 생성하고 API 키를 저장해두세요.

    # .env 파일 내용
    OPENAI_API_KEY=your_openai_api_key_here
    

    Python 코드에서는 dotenv 라이브러리를 사용해 이 키를 로드합니다.

    import os
    from dotenv import load_dotenv
    
    load_dotenv()  # .env 파일에서 환경 변수 로드
    
    # 이제 os.getenv("OPENAI_API_KEY") 등으로 API 키에 접근 가능합니다.
    

    3.3. 문서 로드 및 분할 (Document Loading & Splitting)

    RAG의 첫 단계는 외부 지식 소스를 LLM이 이해할 수 있는 형태로 준비하는 거예요. LangChain은 다양한 포맷의 문서를 로드하는 기능을 제공합니다. 저는 간단한 텍스트 파일(.txt)을 사용해 보겠습니다.

    문서를 불러온 후에는 LLM이 처리하기 좋은 크기로 분할(Chunking)해야 해요. 너무 크면 문맥을 놓칠 수 있고, 너무 작으면 정보의 맥락이 끊어질 수 있거든요. RecursiveCharacterTextSplitter를 주로 사용하는데, 재귀적으로 텍스트를 분할하면서 지정된 크기를 유지하도록 도와줍니다.

    from langchain.document_loaders import TextLoader
    from langchain.text_splitter import RecursiveCharacterTextSplitter
    
    # 1. 문서 로드
    loader = TextLoader("path/to/your/document.txt", encoding="utf-8")
    documents = loader.load()
    
    # 2. 문서 분할
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
    chunks = text_splitter.split_documents(documents)
    
    print(f"총 {len(chunks)}개의 청크로 분할되었습니다.")
    

    3.4. 벡터 데이터베이스 설정 및 데이터 임베딩

    분할된 텍스트 청크를 벡터 데이터베이스에 저장해야 해요. 이 과정에서 임베딩 모델을 사용하여 각 텍스트 청크를 벡터로 변환합니다. 저는 OpenAI의 임베딩 모델을 사용하겠습니다.

    ChromaDB는 로컬에서 쉽게 사용할 수 있는 좋은 옵션이에요. Chroma.from_documents() 함수를 사용하면 문서 로딩, 임베딩, 벡터 DB 저장까지 한 번에 처리할 수 있어서 매우 편리합니다.

    from langchain_openai import OpenAIEmbeddings
    from langchain_community.vectorstores import Chroma
    
    # 임베딩 모델 설정 (OpenAI 사용 시 API 키 필요)
    embeddings = OpenAIEmbeddings()
    
    # ChromaDB 벡터 스토어 생성 및 문서 저장
    # persist_directory는 데이터를 디스크에 저장할 경로입니다.
    vectorstore = Chroma.from_documents(
        chunks,
        embeddings,
        persist_directory="./chroma_db"
    )
    
    print("벡터 데이터베이스에 문서가 성공적으로 저장되었습니다!")
    

    텍스트 문서를 임베딩하여 벡터로 변환 후 ChromaDB에 저장하는 과정입니다.

    3.5. RAG 체인 구성 및 질문 실행

    이제 마지막 단계예요. 검색기(Retriever)를 생성하고, 이를 LLM과 연결하여 RAG 체인을 완성합니다. LangChain의 create_stuff_documents_chain과 create_retrieval_chain을 사용하면 이 과정을 쉽게 구현할 수 있거든요.

    Retriever는 벡터 데이터베이스에서 질문과 가장 유사한 청크들을 검색하는 역할을 해요. vectorstore.as_retriever()로 간단하게 생성할 수 있습니다.

    from langchain_openai import ChatOpenAI
    from langchain.chains import create_retrieval_chain
    from langchain.chains.combine_documents import create_stuff_documents_chain
    
    # LLM 모델 설정 (GPT-3.5 Turbo 사용 예시)
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
    
    # RAG 프롬프트 템플릿
    from langchain_core.prompts import ChatPromptTemplate
    
    prompt = ChatPromptTemplate.from_template(
        """
        다음은 관련 정보를 검색한 내용입니다.
        이 정보를 바탕으로 질문에 답해주세요.
        만약 정보를 찾을 수 없다면, 정보가 없다고 말해주세요.
    
        컨텍스트:
        {context}
    
        질문:
        {input}
        """
    )
    
    # 문서 체인 생성
    document_chain = create_stuff_documents_chain(llm, prompt)
    
    # 검색기(Retriever) 생성
    retriever = vectorstore.as_retriever()
    
    # 검색 및 답변 체인 생성
    retrieval_chain = create_retrieval_chain(retriever, document_chain)
    
    # 질문 실행
    question = "RAG 기술의 주요 목적은 무엇인가요?"
    response = retrieval_chain.invoke({"input": question})
    
    print(f"질문: {question}")
    print(f"답변: {response['answer']}")
    

    코드를 실행하면, 준비된 문서에서 관련 정보를 검색하여 LLM이 답변을 생성하는 것을 볼 수 있어요. 제가 준비한 문서에는 RAG의 목적에 대한 내용이 포함되어 있었기 때문에, LLM이 정확하게 답변해 줄 겁니다. 와, 드디어 됐다! 🎉

    4. 주의사항 및 트러블슈팅 ⚠️

    RAG 구현은 생각보다 간단해 보이지만, 실제 운영 환경에서는 몇 가지 주의해야 할 점들이 있어요. 저도 몇 번의 삽질을 통해 배운 내용들을 공유해 드릴게요.

    • 청크 크기 및 오버랩: 청크 크기(chunk_size)와 오버랩(chunk_overlap) 설정은 검색 성능에 큰 영향을 미칩니다. 너무 작으면 문맥이 끊기고, 너무 크면 관련 없는 정보가 많이 포함될 수 있어요. 다양한 값을 테스트하며 최적의 값을 찾아야 합니다. 제 경험상 500~1000 토큰 사이의 chunk_size와 100~200 토큰 사이의 chunk_overlap이 무난하더라고요.
    • 임베딩 모델 선택: 어떤 임베딩 모델을 사용하느냐에 따라 검색 정확도가 달라집니다. OpenAI 모델이 성능이 좋지만 비용이 발생하죠. Hugging Face의 오픈소스 모델 중에서도 좋은 성능을 내는 모델들이 많으니, 필요에 따라 비교해보는 게 좋습니다.
    • 벡터 데이터베이스 선택: ChromaDB는 로컬 테스트에 좋지만, 대규모 서비스에서는 확장성이나 성능 면에서 FAISS, Milvus, Pinecone 같은 전문 벡터 DB를 고려해야 할 수 있어요.
    • 프롬프트 엔지니어링: LLM에게 어떤 지시를 내리느냐에 따라 답변의 품질이 크게 달라집니다. 컨텍스트를 어떻게 활용하고, 어떤 상황에서 “모른다”고 답해야 하는지 등을 명확하게 지시하는 프롬프트 작성 능력이 중요해요.
    • 성능 저하: 문서의 양이 많아질수록 검색 속도가 느려질 수 있어요. 이 경우, 벡터 DB의 인덱싱 전략을 최적화하거나, 더 효율적인 검색 알고리즘을 도입하는 등의 성능 개선 작업이 필요합니다.

    가장 흔하게 겪는 문제는 “왜 관련 없는 정보가 검색될까?” 또는 “내가 찾는 정보가 안 나와!” 하는 경우인데요. 이때는 보통 임베딩 모델이나 청크 크기 설정을 의심해 봐야 합니다. 저도 처음에 이걸 몰라서 한참 헤맸다니까요. 😂

    RAG 시스템의 질문 답변 정확도, 검색 속도 등을 모니터링하는 대시보드 예시입니다.

    5. 검증 및 결과 확인

    구현한 RAG 시스템의 성능을 확인하는 건 매우 중요해요. 단순히 질문에 답변이 나오는지 확인하는 것을 넘어, 얼마나 정확하고 관련성 높은 답변을 생성하는지 평가해야 합니다.

    가장 간단한 방법은 다양한 질문을 던져보고 답변의 품질을 육안으로 평가하는 거예요. 하지만 더 체계적인 평가를 위해서는 다음과 같은 지표들을 고려할 수 있습니다.

    • 정확도 (Accuracy): 생성된 답변이 사실에 부합하는가?
    • 관련성 (Relevance): 생성된 답변이 질문과 얼마나 관련이 있는가?
    • 최신성 (Freshness): 답변이 최신 정보를 반영하고 있는가?
    • 환각 방지 (Hallucination Reduction): 사실이 아닌 정보를 생성하지 않는가?

    LangChain에서는 이러한 평가를 자동화하기 위한 라이브러리들도 제공하고 있어요. 예를 들어, 특정 질문에 대해 예상되는 답변과 실제 생성된 답변을 비교하거나, 검색된 문서의 관련성을 평가하는 등의 방식으로 시스템을 검증할 수 있습니다.

    직접 테스트해보니, RAG를 적용했을 때 LLM의 답변이 훨씬 더 구체적이고 신뢰할 수 있게 되었어요. 특히 전문 분야나 최신 정보에 대한 질문에서 그 차이가 두드러지더라고요. 👍

    6. 마무리하며: RAG, LLM 활용의 새로운 지평을 열다

    오늘은 LLM의 환각 현상을 줄이고 최신 정보를 활용하기 위한 RAG(Retrieval Augmented Generation) 기술에 대해 알아봤습니다. LangChain과 벡터 데이터베이스를 활용하여 RAG 파이프라인을 직접 구현해보는 과정을 통해, LLM의 한계를 극복하고 더욱 강력하고 신뢰할 수 있는 AI 애플리케이션을 만들 수 있다는 걸 확인했어요.

    RAG는 단순히 LLM의 성능을 보완하는 것을 넘어, LLM이 특정 도메인의 전문 지식을 갖추고 실시간 정보를 반영하도록 만드는 핵심 기술이에요. 앞으로 RAG는 고객 지원 챗봇, 내부 문서 검색 시스템, 개인 맞춤형 정보 제공 등 정말 다양한 분야에서 활용될 거예요. 저도 이 기술을 활용해서 홈랩 프로젝트에 적용해볼 계획이거든요. 기대되지 않으신가요?

    RAG 기술이 적용될 수 있는 다양한 산업 분야와 서비스 예시입니다.

    이번 글이 RAG 기술에 대한 이해를 높이고, 직접 구현해보는 데 도움이 되었기를 바랍니다. 다음 글에서는 RAG 성능을 더욱 향상시킬 수 있는 고급 기법들에 대해 다뤄볼 예정이니, 많은 기대 부탁드립니다!

    핵심 요약:

    • LLM 환각 현상: LLM이 사실이 아닌 정보를 생성하는 문제
    • RAG (Retrieval Augmented Generation): 외부 정보 검색 후 LLM 답변 생성
    • 핵심 도구: LangChain (프레임워크), 벡터 DB (ChromaDB 등), 임베딩 모델
    • 구현 절차: 문서 로드/분할 → 임베딩/벡터 DB 저장 → RAG 체인 구성 → 질문 실행
    • 주의사항: 청크 크기, 임베딩 모델, 프롬프트 엔지니어링 등

    궁금한 점이 있다면 언제든지 댓글로 남겨주세요!