고급 청킹

from langchain.retrievers import ParentDocumentRetriever
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.storage import InMemoryStore
from langchain_databricks import DatabricksVectorSearch

# Child 청크용 스플리터 (검색용 - 작은 크기)
child_splitter = RecursiveCharacterTextSplitter(
    chunk_size=200,
    chunk_overlap=30,
    separators=["\n\n", "\n", ".", "!", "?", " "]
)

# Parent 청크용 스플리터 (LLM 전달용 - 큰 크기)
parent_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=100,
    separators=["\n\n", "\n", ".", "!", "?", " "]
)

# Parent Document Retriever 설정
store = InMemoryStore()  # Parent 청크 저장소 (프로덕션에서는 Redis/Delta 사용)

parent_retriever = ParentDocumentRetriever(
    vectorstore=vectorstore,        # Child 청크가 저장된 벡터 스토어
    docstore=store,                 # Parent 청크 저장소
    child_splitter=child_splitter,
    parent_splitter=parent_splitter,
)

# 문서 추가 (자동으로 Parent/Child 분할)
parent_retriever.add_documents(documents)

# 검색: Child로 매칭, Parent를 반환
results = parent_retriever.invoke("Unity Catalog 권한 설정 방법")
# → Child 크기(200토큰)로 정확한 매칭 수행
# → 해당 Child의 Parent(1000토큰)를 반환하여 LLM에 풍부한 문맥 제공

from langchain_experimental.text_splitter import SemanticChunker
from langchain_databricks import DatabricksEmbeddings

embeddings = DatabricksEmbeddings(endpoint="databricks-bge-large-en")

# 의미 기반 청킹: 코사인 유사도 변화 지점에서 분할
semantic_splitter = SemanticChunker(
    embeddings=embeddings,
    breakpoint_threshold_type="percentile",  # 유사도 변화가 상위 N%일 때 분할
    breakpoint_threshold_amount=95,          # 상위 5% 변화 지점에서 분할
)

chunks = semantic_splitter.create_documents([long_document_text])
print(f"의미 기반 분할 결과: {len(chunks)}개 청크")

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

PROPOSITION_PROMPT = """다음 텍스트를 독립적 명제(self-contained proposition)들로 분해하세요.

규칙:
1. 각 명제는 다른 명제 없이도 완전히 이해 가능해야 합니다
2. 대명사를 구체적 명사로 교체하세요 ("그것" → 실제 대상)
3. 암묵적 주어/목적어를 명시하세요
4. 각 명제는 하나의 사실만 포함하세요
5. 원본의 의미를 변경하지 마세요

텍스트:
{text}

JSON 형식으로 출력:
{{"propositions": ["명제1", "명제2", ...]}}
"""

def extract_propositions(text: str) -> list[str]:
    """텍스트에서 독립적 명제를 추출"""
    response = w.serving_endpoints.query(
        name="databricks-claude-sonnet-4",
        messages=[{"role": "user", "content": PROPOSITION_PROMPT.format(text=text)}],
        temperature=0.0,
    )
    import json
    result = json.loads(response.choices[0].message.content)
    return result["propositions"]

# 사용 예시
text = """Unity Catalog는 Databricks의 통합 거버넌스 솔루션이다.
이것은 2022년에 출시되었으며, 기존의 Hive Metastore를 대체한다.
주요 기능으로 3단계 네임스페이스(catalog.schema.table)와
행/열 수준의 접근 제어를 제공한다."""

propositions = extract_propositions(text)
# 결과:
# [
#   "Unity Catalog는 Databricks의 통합 거버넌스 솔루션이다",
#   "Unity Catalog는 2022년에 출시되었다",
#   "Unity Catalog는 기존의 Hive Metastore를 대체한다",
#   "Unity Catalog는 3단계 네임스페이스(catalog.schema.table)를 제공한다",
#   "Unity Catalog는 행 수준의 접근 제어를 제공한다",
#   "Unity Catalog는 열 수준의 접근 제어를 제공한다"
# ]

기존: [청크1 임베딩] [청크2 임베딩] [청크3 임베딩]
       ↑ 청크1만 봄    ↑ 청크2만 봄    ↑ 청크3만 봄

Late: [============ 전체 문서 임베딩 ============]
       [청크1 pooling]  [청크2 pooling]  [청크3 pooling]
       ↑ 전체 문맥 반영  ↑ 전체 문맥 반영  ↑ 전체 문맥 반영

from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_recall, context_precision
from langchain.text_splitter import RecursiveCharacterTextSplitter

# 평가 데이터셋 (질문, 정답, 원본 문서)
eval_dataset = [...]  # 50~100개의 Q&A 쌍

chunk_sizes = [100, 200, 500, 1000, 2000]
results = {}

for size in chunk_sizes:
    # 1. 청킹
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=size, chunk_overlap=int(size * 0.2)
    )
    chunks = splitter.split_documents(documents)

    # 2. 임베딩 + 벡터 저장
    vectorstore = create_vectorstore(chunks)

    # 3. RAG 파이프라인으로 답변 생성
    answers = [rag_pipeline(q, vectorstore) for q in eval_dataset]

    # 4. RAGAS 평가
    score = evaluate(
        dataset=answers,
        metrics=[faithfulness, answer_relevancy, context_recall, context_precision],
    )
    results[size] = score

# 5. 결과 비교
for size, score in results.items():
    print(f"Chunk {size}: Faithfulness={score['faithfulness']:.3f}, "
          f"Recall={score['context_recall']:.3f}, "
          f"Precision={score['context_precision']:.3f}")

# Databricks ai_parse_document로 표 추출
# SQL에서 직접 사용 가능
"""
SELECT ai_parse_document(
  content,
  'tables'  -- 표 구조를 별도로 추출
) AS parsed
FROM raw_documents
"""

from langchain.text_splitter import Language, RecursiveCharacterTextSplitter

# Python 코드 전용 스플리터
code_splitter = RecursiveCharacterTextSplitter.from_language(
    language=Language.PYTHON,
    chunk_size=1000,
    chunk_overlap=100,
)
# 함수, 클래스 경계를 인식하여 분할

# Databricks ai_parse_document를 활용한 PDF 레이아웃 인식 파싱
# 헤더, 본문, 표, 이미지 캡션을 구조적으로 분리

"""
SELECT ai_parse_document(
  pdf_content,
  'layout'  -- 레이아웃 인식 모드
) AS parsed
FROM pdf_documents
"""
# 결과: 헤더별 섹션, 표, 이미지 설명이 구조화된 형태로 추출

오버랩 없음 (chunk_overlap=0):
  [Unity Catalog는 3단계 네임스페이스를] | [제공한다. catalog.schema.table 형식이다.]
  → "Unity Catalog의 네임스페이스 형식은?" 검색 시,
    청크1은 "형식"이 없고, 청크2는 "Unity Catalog"가 없어 매칭 실패

오버랩 있음 (chunk_overlap=20%):
  [Unity Catalog는 3단계 네임스페이스를 제공한다.]
                           [네임스페이스를 제공한다. catalog.schema.table 형식이다.]
  → 오버랩 구간에 핵심 정보 보존 → 검색 성공

Retrieval Recall@K = (상위 K개 검색 결과에 정답 청크가 포함된 비율)

def evaluate_chunking_recall(questions, ground_truth_chunks, vectorstore, k=5):
    """청킹 전략의 Retrieval Recall@K 측정"""
    hits = 0
    for question, gt_chunk in zip(questions, ground_truth_chunks):
        results = vectorstore.similarity_search(question, k=k)
        retrieved_texts = [r.page_content for r in results]

        # ground truth 청크가 검색 결과에 포함되었는가?
        if any(gt_chunk in text for text in retrieved_texts):
            hits += 1

    recall = hits / len(questions)
    return recall

# 청킹 전략별 비교
for strategy_name, vectorstore in strategies.items():
    recall = evaluate_chunking_recall(questions, gt_chunks, vectorstore, k=5)
    print(f"{strategy_name}: Recall@5 = {recall:.3f}")

# 예시 결과:
# Fixed(500):     Recall@5 = 0.72
# Recursive(500): Recall@5 = 0.81
# Semantic:       Recall@5 = 0.85
# Parent-Child:   Recall@5 = 0.88
# Proposition:    Recall@5 = 0.91