13년차의 서버실

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

[태그:] 임베딩

  • [AI] 벡터 DB Qdrant vs Chroma: 1년 사용 후기 및 마이그레이션 고려사항

    [AI] 벡터 DB Qdrant vs Chroma: 1년 사용 후기 및 마이그레이션 고려사항

    [AI] 벡터 DB Qdrant vs Chroma: 1년 사용 후기 및 마이그레이션 고려사항

    벡터 DB 비교를 진지하게 해야 하는 시점이 생각보다 빨리 오더라고요. 처음엔 RAG(Retrieval-Augmented Generation, 검색 증강 생성) PoC(개념 검증)만 돌리면 끝날 줄 알았는데, 문서 수가 늘고 메타데이터 필터가 복잡해지고 운영 환경이 붙기 시작하면 이야기가 달라집니다. 저도 홈랩과 업무성 PoC에서 Qdrant와 Chroma를 번갈아 써보면서, “둘 다 벡터 데이터베이스인데 왜 이렇게 운영 감각이 다르지?” 싶었던 순간이 꽤 많았습니다. 특히 1년 정도 굴려보니 단순 기능 비교보다, 마이그레이션과 운영 난이도에서 체감 차이가 더 크게 오더라고요.

    이번 글은 Qdrant, Chroma를 실제 운영 관점에서 어떻게 봐야 하는지 정리한 글입니다. 성능 수치 뻥튀기나 벤치마크 놀이는 일부러 뺐습니다. 대신 어떤 팀에 어떤 선택이 맞는지, 그리고 나중에 옮길 때 어디서 삽질하기 쉬운지 중심으로 적어보겠습니다. 혹시 지금 “일단 Chroma로 시작하고 나중에 Qdrant로 옮기면 되겠지” 혹은 반대로 “Qdrant가 더 본격적이니 무조건 그게 답 아닌가?” 고민하고 계시면 꽤 현실적인 판단 기준이 되실 겁니다.

    벡터 DB 비교를 위한 Qdrant와 Chroma 아키텍처 개요 이미지

    Qdrant와 Chroma가 애플리케이션, 임베딩 모델, 메타데이터 필터, 저장소 계층에서 어떻게 연결되는지 한눈에 보여주는 개요도입니다.

    1. 벡터 데이터베이스, 쉽게 말해 뭐가 다른 걸까요?

    쉽게 말해 벡터 데이터베이스(Vector Database, 벡터 유사도 검색용 저장소)는 텍스트나 이미지에서 뽑아낸 임베딩(Embedding, 의미를 숫자 배열로 바꾼 값)을 저장하고, 비슷한 의미를 가진 데이터를 빠르게 찾는 데 특화된 저장소입니다. 일반 RDBMS(관계형 데이터베이스)로도 못 하는 건 아니지만, 문서 수가 늘어나고 의미 기반 검색이 들어가면 관리 포인트가 확 늘어납니다.

    근데 여기서 중요한 포인트가 있습니다. 벡터 검색만 되면 끝이 아니거든요. 실제 서비스에서는 메타데이터 필터링, 컬렉션 설계, 백업, 복구, 멀티테넌시(Multitenancy, 여러 고객/조직을 분리 운영하는 구조), 클라이언트 연결 방식까지 같이 봐야 합니다. 제가 처음엔 이걸 가볍게 봤다가 나중에 마이그레이션에서 삽질 좀 했습니다 ㅎㅎ

    Qdrant와 Chroma의 결 차이

    항목 Qdrant Chroma
    기본 인상 운영형 벡터 데이터베이스에 가깝습니다 개발 친화적인 검색 스토어 느낌이 강합니다
    실행 방식 독립 서비스로 띄워서 REST/gRPC로 붙는 흐름이 자연스럽습니다 인메모리, PersistentClient, HTTP 서버 모드까지 시작 진입장벽이 낮습니다
    필터링 payload 기반 필터가 강력하고 인덱스 전략까지 같이 봅니다 metadata filtering 문법이 직관적이라 빠르게 붙이기 좋습니다
    운영 기능 snapshot, migration tool, quantization, multitenancy 같은 운영 기능이 잘 보입니다 빠른 로컬 실험과 애플리케이션 내장형 흐름이 편합니다
    확장 관점 서비스화할수록 장점이 커집니다 작게 시작할 때 속도가 좋습니다
    마이그레이션 포인트 컬렉션 설정과 필터 인덱스를 미리 설계하면 안정적입니다 버전별 동작 차이와 저장 방식 변화 체크가 중요합니다

    제 경험상 정리하면 이렇습니다. Chroma는 시작이 빠르고, Qdrant는 운영이 길어질수록 편해집니다. 물론 예외는 있습니다. 데이터가 작고 단일 앱 내부에서만 쓰는 경우엔 Chroma가 정말 편합니다. 반대로 여러 워커가 붙고 백업과 복구를 신경 써야 하면 Qdrant 쪽이 마음이 놓이더라고요.

    2. Qdrant vs Chroma를 나눠보는 기준

    벡터 DB 비교를 할 때 제가 실제로 보는 기준은 딱 다섯 가지입니다.

    • 데이터 영속성(Persistence, 디스크에 안전하게 남는가)
    • 필터링 모델(메타데이터 검색이 얼마나 자연스러운가)
    • 운영 기능(백업, 복구, 재배치, 멀티테넌시)
    • 클라이언트 연결 방식(앱 안에서 바로 쓰는지, 서버를 두는지)
    • 마이그레이션 비용(나중에 옮길 때 고생하는 포인트가 뭔지)

    Qdrant는 컬렉션(Collection, 벡터를 담는 논리 단위)과 포인트(Point, 벡터+메타데이터 단위) 개념이 비교적 명확하고, payload(페이로드, 메타데이터) 필터를 중심으로 운영 설계를 하게 됩니다. 문서상으로도 필터링, 하이브리드 쿼리(Hybrid Queries, 벡터 검색과 다른 검색 조건 결합), 스냅샷, 데이터 마이그레이션이 잘 드러납니다. 반면 Chroma는 클라이언트 관점이 더 앞에 나옵니다. `Client()`, `PersistentClient()`, `HttpClient()` 흐름이 명확해서 개발자가 바로 붙이기 편합니다.

    이 차이가 실제론 꽤 큽니다. 개발 초기엔 Chroma가 “드디어 됐다!” 싶은 속도를 주고, 운영 단계에선 Qdrant가 “이거 복구 시나리오까지 생각해놨네” 하는 안정감을 줍니다.

    3. 실전 구현: 둘 다 같은 조건으로 빠르게 띄워보기

    말로만 비교하면 감이 잘 안 오니까, 가장 단순한 방식으로 둘 다 띄워보겠습니다. 제가 실험할 때도 항상 같은 문서 샘플, 같은 메타데이터 구조로 먼저 맞춰봅니다. 그래야 나중에 마이그레이션 판단이 쉬워지거든요.

    3-1. Qdrant 실행

    docker pull qdrant/qdrant
    
    docker run -p 6333:6333 -p 6334:6334 \
      -v "$(pwd)/qdrant_storage:/qdrant/storage:z" \
      qdrant/qdrant

    Qdrant는 이렇게 독립 서비스로 띄우는 흐름이 자연스럽습니다. REST API는 `6333`, gRPC는 `6334`를 기본으로 씁니다. 운영 생각이 조금이라도 있으면 저는 처음부터 볼륨 마운트를 잡아둡니다. 안 그러면 테스트는 쉬운데 나중에 데이터 보존 흐름이 꼬이더라고요.

    3-2. Chroma 실행

    docker pull chromadb/chroma
    
    docker run -p 8000:8000 chromadb/chroma

    Chroma는 서버 모드도 가능하지만, 로컬 실험에서는 Python `Client()`나 `PersistentClient()`로 바로 붙는 맛이 좋습니다. 빠르게 아이디어 검증할 때 이 장점이 꽤 큽니다.

    3-3. Docker Compose로 같이 올리기

    services:
      qdrant:
        image: qdrant/qdrant
        ports:
          - "6333:6333"
          - "6334:6334"
        volumes:
          - ./qdrant_storage:/qdrant/storage
    
      chroma:
        image: chromadb/chroma
        ports:
          - "8000:8000"

    처음엔 각각 따로 띄웠었는데, 나중엔 결국 이렇게 같이 올려놓고 같은 데이터셋으로 비교하게 되더라고요. 벡터 DB 비교는 이 습관이 정말 중요합니다.

    로컬 홈랩 환경에서 Qdrant와 Chroma를 나란히 띄우고 같은 샘플 데이터를 넣는 실습 구성을 표현한 이미지입니다.

    4. 같은 데이터를 넣어보면 차이가 더 선명합니다

    아래 예시는 기능을 뽐내기보다는, 실제 마이그레이션 전 체크해야 하는 최소 단위를 보여주기 위한 코드입니다. 핵심은 문서, ID, 메타데이터 키 구조를 처음부터 고정하는 겁니다.

    4-1. Chroma 예시

    import chromadb
    
    client = chromadb.PersistentClient(path="./chroma_data")
    collection = client.get_or_create_collection(name="docs")
    
    collection.add(
        ids=["doc-1", "doc-2"],
        documents=[
            "nginx ingress timeout troubleshooting",
            "qdrant payload filtering notes"
        ],
        metadatas=[
            {"service": "ingress", "env": "lab"},
            {"service": "vector-db", "env": "lab"}
        ]
    )
    
    result = collection.query(
        query_texts=["vector database filter"],
        n_results=2,
        where={"env": "lab"}
    )
    
    print(result)

    Chroma는 여기까지 오는 속도가 정말 빠릅니다. `PersistentClient`만 써도 디스크에 저장되고, 메타데이터 필터 문법도 직관적입니다. 제가 처음 RAG 프로토타입 만들 때는 솔직히 이 편의성이 꽤 크게 느껴졌습니다.

    4-2. Qdrant 예시

    from qdrant_client import QdrantClient
    from qdrant_client.models import Distance, VectorParams
    
    client = QdrantClient(url="http://localhost:6333")
    
    client.create_collection(
        collection_name="docs",
        vectors_config=VectorParams(size=4, distance=Distance.COSINE)
    )
    curl -X PUT http://localhost:6333/collections/docs/points \
      -H 'Content-Type: application/json' \
      -d '{
        "points": [
          {
            "id": 1,
            "vector": [0.05, 0.61, 0.76, 0.74],
            "payload": {"service": "ingress", "env": "lab"}
          },
          {
            "id": 2,
            "vector": [0.19, 0.81, 0.75, 0.11],
            "payload": {"service": "vector-db", "env": "lab"}
          }
        ]
      }'

    Qdrant는 시작이 조금 더 “DB를 세팅한다”는 느낌입니다. 대신 구조가 또렷합니다. payload 필터, 컬렉션 설정, 나중에 붙일 인덱스 전략까지 그림이 잘 나옵니다. 실제로 써보니까 검색 품질보다도 운영 설계를 앞당겨 생각하게 만드는 쪽은 Qdrant였습니다.

    4-3. 필터링 관점 차이

    Chroma는 `where` 문법이 친숙하고, OR 조건이나 배열 포함 조건도 비교적 읽기 쉽습니다. Qdrant는 `must`, `should`, `match`, `range` 중심의 필터 모델이라 처음엔 약간 더 장비 만지는 느낌이 납니다. 근데 조건이 복잡해질수록 저는 Qdrant 쪽이 더 예측 가능하더라고요.

    특히 Qdrant는 필터링 성능을 위해 payload index를 고려하라는 흐름이 명확합니다. 이건 운영 단계에서 꽤 중요합니다. 개발할 땐 그냥 되면 됐지 싶었는데, 데이터가 쌓이면 이 차이가 바로 체감됩니다.

    5. 마이그레이션 고려사항: 여기서 진짜 차이가 납니다

    이 섹션이 사실 핵심입니다. 벡터 데이터베이스를 바꾼다는 건 단순 dump/import가 아니더라고요. 임베딩 모델, ID 체계, 메타데이터 스키마, 필터 문법, 컬렉션 설정이 다 얽혀 있습니다.

    1. 임베딩 차원 수를 먼저 확인하세요. Qdrant는 컬렉션 생성 시 벡터 크기를 정하게 되고, 다른 차원의 임베딩을 넣으면 바로 문제가 납니다. 마이그레이션 전에 현재 임베딩 모델의 차원 수를 먼저 고정해두는 게 좋습니다.
    2. ID 전략을 통일하세요. 숫자 ID인지 문자열 ID인지, 외부 문서 ID를 그대로 쓸지 내부 생성 ID를 쓸지 먼저 정해야 합니다. 나중에 재색인(reindex)할 때 이게 꼬이면 검증이 매우 힘들어집니다.
    3. 메타데이터 키를 평평하게 유지하세요. `service`, `env`, `owner`, `source`처럼 자주 쓰는 키를 정규화해두면 Chroma에서 Qdrant로 옮길 때도 덜 아픕니다.
    4. 필터 의미가 같은지 꼭 재검증하세요. 같은 조건처럼 보여도 결과가 미묘하게 다를 수 있습니다. Chroma는 버전 변화로 `where` 동작이 바뀐 항목들이 있었고, Qdrant는 필터 구조가 더 명시적이라 쿼리 변환 시 검증이 필요합니다.
    5. 백업 방식과 이전 방식은 구분해서 보세요. Qdrant는 snapshot 기반 복구가 강하고, 별도 migration tool은 스트리밍 전송과 재개(resume)에 강점이 있습니다. 목적이 같아 보이지만 실제 용도는 꽤 다릅니다.

    여기서 제가 가장 많이 놓쳤던 건 필터 문법보다 필터 의미였습니다. 예를 들어 Chroma 쪽은 버전에 따라 `where`의 일부 연산자 동작이 바뀐 적이 있습니다. 또 오래된 저장 구조를 쓰던 환경에서는 `chroma-migrate`로 데이터 레이아웃을 올려야 하는 케이스도 있었습니다. 예전 방식에서 `duckdb`/`clickhouse` 기반 메타데이터 저장을 쓰다가 `sqlite` 기반으로 넘어가는 변화가 있었기 때문에, 오래된 로컬 데이터면 이 부분을 꼭 체크하셔야 합니다.

    pip install chroma-migrate
    chroma-migrate

    이거 저도 처음엔 “에이, 그냥 패키지 업그레이드면 끝나겠지” 했었는데 아니더라고요. 버전 점프가 큰 환경은 특히 조심하셔야 합니다.

    반대로 Qdrant 쪽은 마이그레이션 관점 문서가 꽤 명확합니다. 같은 클러스터 복구나 로컬 백업이면 snapshot이 맞고, 다른 환경으로 옮기거나 중간에 끊겨도 다시 이어가야 하는 흐름이면 migration tool 쪽이 더 자연스럽습니다. 컬렉션 설정을 바꾸면서 옮길 수 있다는 점도 운영에서는 꽤 실용적입니다.

    6. ⚠️ 실제로 겪었던 문제와 해결법

    6-1. Chroma는 빠른데, 버전 변화 체크를 안 하면 발목을 잡습니다

    Chroma는 진입 속도가 빠른 대신, 오래 유지된 로컬 테스트 환경을 운영 비슷하게 끌고 가면 예상 못 한 차이를 만날 수 있습니다. 예를 들어 `get_or_create_collection`의 동작이나, `where` 관련 연산자의 의미가 버전에 따라 바뀐 부분은 꼭 확인하셔야 합니다. 특히 빈 딕셔너리나 빈 리스트 필터를 관성적으로 넘기던 코드가 나중에 깨질 수 있습니다.

    해결 팁은 간단합니다. 업그레이드 전후로 샘플 질의를 고정해두고, 결과 ID 집합이 같은지 비교하세요. 사람 눈으로 보면 비슷한데 실제 검색 결과가 달라지는 케이스가 있거든요.

    6-2. Qdrant는 필터 인덱스를 늦게 보면 운영 때 아쉽습니다

    Qdrant는 payload 필터를 많이 쓸 예정이라면, 어떤 필드를 자주 거를지 초기에 정하는 게 좋습니다. 저도 처음엔 벡터 검색만 잘 되면 된다고 생각했는데, 실제로는 `env=prod`, `service=api`, `tenant=team-a` 같은 필터가 계속 붙더라고요. 그때서야 필드 전략을 다시 손보면 좀 번거롭습니다.

    해결 팁은 검색 패턴을 먼저 적는 겁니다. 어떤 메타데이터 조합을 가장 자주 쓰는지 적고 시작하면 payload 설계가 훨씬 안정적입니다.

    6-3. 마이그레이션은 데이터보다 검증이 더 오래 걸립니다

    이건 진짜입니다. 데이터 옮기는 명령어 자체보다, 옮긴 뒤에 “제대로 됐는지” 확인하는 시간이 더 깁니다. 총 문서 수, ID 누락, 대표 질의 결과, 메타데이터 필터 결과를 전부 비교해야 하거든요. 처음엔 이게 뭔가 싶었는데, 한 번만 대충 하고 나면 꼭 나중에 후회합니다.

    벡터 DB 비교에서 중요한 마이그레이션 검증 흐름 이미지

    컬렉션 설계, 메타데이터 키 정리, 필터 의미 검증, 백업과 이전 전략 분리를 한 장에 정리한 마이그레이션 흐름도입니다.

    7. 검증과 결과: 어떤 상황에서 무엇이 더 편했나

    제가 실제로 써보니까 결론은 꽤 선명했습니다.

    • 빠른 PoC와 로컬 실험: Chroma가 더 편했습니다
    • 장기 운영과 복구 시나리오: Qdrant가 더 편했습니다
    • 앱 코드 안에서 바로 돌려보기: Chroma가 부담이 적었습니다
    • 서비스로 분리하고 운영 규칙을 붙이기: Qdrant가 잘 맞았습니다

    Chroma는 `PersistentClient` 하나로 시작할 수 있어서 개발 속도가 정말 좋습니다. 문서 몇천 개 수준에서 빠르게 실험하고, 애플리케이션 코드 안에서 검색 레이어를 붙이는 경험은 상당히 부드럽습니다. 반면 Qdrant는 처음부터 서비스 경계가 뚜렷해서, 팀이 붙고 환경이 나뉘고 복구 전략이 필요해질수록 강점이 살아납니다.

    그리고 벡터 DB 비교에서 자주 놓치는 포인트가 하나 더 있습니다. 지금 편한 도구와 나중에 덜 아픈 도구가 다를 수 있다는 겁니다. 이 차이를 미리 받아들이면 선택이 훨씬 쉬워집니다.

    벡터 DB 비교 결과를 보여주는 Qdrant와 Chroma 대시보드 이미지

    문서 수, 필터 사용 빈도, 운영 편의성, 마이그레이션 리스크를 비교하는 대시보드 스타일의 결과 시각화입니다.

    8. 자주 묻는 질문 정리

    Q. Chroma로 시작했다가 나중에 Qdrant로 옮겨도 될까요?

    네, 충분히 가능합니다. 다만 임베딩 차원, ID 체계, 메타데이터 키 구조를 초기에 잘 잡아두셔야 합니다. 이걸 대충 두면 나중에 옮기는 비용이 확 올라갑니다.

    Q. Qdrant가 무조건 더 좋은가요?

    그건 아닙니다. 운영형 요구사항이 아직 없고, 개발 생산성이 더 중요하면 Chroma가 오히려 더 좋은 선택일 수 있습니다. 특히 로컬 실험과 앱 내장형 흐름은 Chroma가 꽤 강합니다.

    Q. 백업은 어떻게 생각하면 좋을까요?

    Qdrant는 snapshot 관점이 분명해서 백업/복구 시나리오를 잡기 좋습니다. Chroma는 사용 모드에 따라 로컬 저장 경로와 업그레이드 절차를 더 꼼꼼히 봐야 합니다.

    Q. 이전 글이나 다음 글과 연결해서 보면 좋은 주제는요?

    이전 글에서 다뤘던 Docker Compose 운영 패턴과 같이 보시면 이해가 빠릅니다. 다음 글에서는 RAG 파이프라인에서 재색인 전략과 임베딩 교체 시 주의점을 따로 다뤄볼 예정입니다.

    PoC, 운영, 백업, 필터링, 마이그레이션 기준으로 Qdrant와 Chroma 선택 포인트를 요약한 인포그래픽입니다.

    9. 마무리: 결국 중요한 건 지금의 편의성과 미래의 운영 비용 균형입니다

    정리해보면 이렇습니다. Chroma는 시작이 빠르고, Qdrant는 운영이 길어질수록 강합니다. 제가 직접 해보니 둘 중 하나가 절대적으로 우월하다기보다는, 팀의 현재 단계가 어디냐에 따라 답이 달라졌습니다. 혼자 혹은 소규모로 빠르게 실험할 때는 Chroma가 진짜 편하더라고요. 반대로 운영 환경 냄새가 나기 시작하면 Qdrant 쪽이 훨씬 안심됐습니다.

    혹시 지금 벡터 DB 비교 때문에 머리가 복잡하시면, 먼저 스스로에게 이렇게 물어보시면 됩니다. “나는 지금 빠르게 검증해야 하나, 아니면 나중에 덜 아파야 하나?” 이 질문에 답이 나오면 선택도 꽤 선명해집니다. 그리고 무엇을 고르든, 메타데이터 스키마와 검증 시나리오부터 잡아두는 것, 이건 진짜 강력 추천드립니다.

    다음 글에서는 Qdrant와 Chroma 위에 RAG 파이프라인을 얹을 때, 재색인 전략과 문서 chunking(청킹, 문서를 작은 단위로 나누는 방식)이 검색 품질에 어떤 차이를 만드는지 이어서 정리해보겠습니다.

  • [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 비용 걱정 없이 사내 문서를 분석하고 싶으신 분들께 도움이 될 거예요. 궁금하신 점은 댓글로 남겨주세요! 🎉