RAG의 활용도를 높일 수 있는 Neo4j 기반 GraphRAG Cookbook

CLOVA Studio 운영자 · 2025-11-04T02:19:05Z

들어가며

작성 배경 및 목적

실무 환경에서는 데이터 간의 복잡한 관계를 탐색하거나, 결과에 대한 명확한 근거 제시가 필요하거나, 여러 단계를 거친 추론이 요구되는 질의가 자주 발생합니다. 본 문서는 이러한 복합 질의 상황에서 전통적인 벡터 기반 RAG(Retrieval-Augmented Generation)의 한계를 보완하기 위해, 데이터의 구조적 관계를 활용한 GraphRAG 파이프라인 구축 방법을 제시합니다. 이를 위해 클로바 스튜디오의 HCX-007 추론 모델과 그래프 데이터베이스 Neo4j를 활용하여 PDF 데이터로부터 지식 그래프를 구축하고, 이를 기반으로 한 Structured Q&A와 기존 Vector Q&A 방식을 결합한 하이브리드 질의응답 시스템의 구현 과정을 다룹니다.

GraphRAG와 Neo4j는 무엇인가?

① GraphRAG: '관계 지도'를 활용하는 차세대 AI 검색

기존 RAG는 사용자의 질문과 의미가 비슷한 텍스트를 찾아 LLM이 참고하도록 하는 방식입니다. 이 방식은 해당 페이지 내의 정보에는 강점을 보이지만, 여러 문서에 흩어져 있는 개념 간 관계를 종합적으로 추론하는 데에는 한계가 있습니다. GraphRAG는 이러한 한계를 넘어, Neo4j에 구축된 지식 그래프(relationship graph)를 함께 활용합니다. 즉, 모델이 참고하는 것은 단순한 텍스트 조각이 아니라 데이터 간의 연결 구조 전체입니다. 이를 통해 개별 정보의 의미뿐 아니라 엔터티 간의 관계를 함께 이해하고, 여러 출처의 데이터를 맥락적으로 통합하며, 보다 정확하고 신뢰할 수 있는 답변을 생성할 수 있습니다.

② Neo4j: 데이터의 관계를 저장하는 데이터베이스

데이터베이스는 대개 정보를 엑셀 시트와 같은 표 형태로 저장합니다. 이 방식은 단순한 데이터를 다룰 때는 효율적이지만, 데이터가 복잡해질수록 구조가 복잡해지고 처리 속도가 떨어집니다. Neo4j는 이러한 한계를 보완하기 위해, 데이터를 관계 중심으로 표현하는 그래프 데이터베이스(Graph Database)입니다. Neo4j는 이러한 접근 방식 대신 데이터를 관계 중심으로 모델링하는 그래프 데이터베이스(Graph Database)로, 복잡한 개체 간의 연결을 노드(Node)와 관계(Relationship) 형태로 자연스럽게 모델링하고 저장합니다.

Neo4j는 데이터를 노드와 관계로 표현해 복잡한 연결 구조를 직관적으로 다룰 수 있습니다. 이런 그래프 기반 구조는 데이터를 빠르고 효율적으로 탐색할 수 있게 해주며, 스키마가 고정돼 있지 않아 새로운 속성이나 관계도 쉽게 추가할 수 있습니다. 또, 그래프 구조에 최적화된 Cypher 쿼리 언어를 지원해 복잡한 질의도 간결하게 작성할 수 있습니다.

③ 온톨로지: 지식 그래프의 설계도

GraphRAG의 성능을 높이기 위해서는 온톨로지(Ontology) 개념이 중요합니다. 온톨로지는 특정 도메인(예: 금융, 의료, 제조 등)의 지식을 체계적으로 표현하기 위한 규칙과 어휘의 집합으로, 지식 그래프의 설계도이자 스키마 역할을 합니다. 온톨로지에서는 어떤 종류의 개체가 존재하는지, 각 개체가 어떤 속성을 가지는지, 그리고 개체 간에 어떤 관계가 가능한지를 미리 정의합니다.

예를 들어 ‘인물’, ‘회사’, ‘프로젝트’ 같은 개체가 있고, 인물은 이름과 직책이라는 속성을 가지며, 회사에 소속되거나(WORKS_FOR) 프로젝트를 관리하는(MANAGES) 관계를 맺을 수 있습니다. Neo4j가 흩어진 정보를 연결해 ‘관계 지도’를 만든다면, 온톨로지는 그 지도에 쓰인 기호의 의미와 규칙을 정의하는 범례 역할을 합니다. GraphRAG은 이 지도와 범례를 함께 활용해 복잡한 질문에 대해 신뢰도 높은 경로를 찾아냅니다.

GraphRAG은 복잡한 관계를 기반으로 한 질의나 설명 가능한 추론이 필요한 환경에서 특히 유용합니다. 예를 들어 기업 조직도나 공급망처럼 개체 간 연결이 많은 구조를 분석하거나, 금융·의료·법률 분야처럼 근거 자료의 추적이 필요한 경우에 적합합니다. 또한 여러 단계의 논리적 연결을 따라가야 하는 복합 질의나, 이미 도메인 지식이 체계화된 산업군에서도 효과적으로 활용할 수 있습니다.

대표적인 활용 분야

금융/리스크/사기 탐지 : 거래 기록, 구성원, 회사 네트워크의 연관성을 분석한 위험 탐지 및 의사결정
법률/규제 : 조문·판례 간의 연결 관계를 활용한 사례 연구 및 근거 탐색
기업 내부 지식/연구 : 다양한 문서·연구자·프로젝트 간 연계를 통한 인사이트 도출 및 지능형 Q&A
고객 서비스 : 복잡한 문의에 대해 근거 기반의 신뢰성 높은 답변 제공

GraphRAG에 HCX-007 추론 모델을 사용해야 하는 이유

GraphRAG에 추론 모델을 사용하는 이유는 그래프 구조 속 관계적 의미를 정확히 이해하고 해석할 수 있기 때문입니다.

1. 뛰어난 추론 및 지시 이행

GraphRAG은 문서에서 엔터티와 관계를 추출해 그래프 형태로 저장합니다. 하지만 단순히 텍스트 유사도를 계산하는 방식만으로는 노드 간의 복잡한 연결이나 간접적인 의미 관계를 충분히 드러내기 어렵습니다. HCX-007 추론 모델은 이러한 한계를 넘어, 여러 노드 사이의 맥락적 연결을 이해하고 문장에 드러나지 않은 논리적 관계를 찾아낼 수 있기 때문에 더 풍부하고 정교한 응답을 제공합니다.

2. 신뢰성 있는 답변 생성

HCX-007 추론 모델은 단순히 답변을 제시하는 데 그치지 않고, 답이 도출된 과정을 함께 보여줄 수 있습니다. 사용자는 이 과정을 통해 결과의 근거를 확인할 수 있으며, 단순한 검색 기반 응답보다 논리적이고 신뢰도 높은 답변을 얻을 수 있습니다.

3. 고품질의 한국어 처리 능력
HCX-007추론 모델은 방대한 한국어 데이터를 기반으로 학습되어, 문맥의 미묘한 차이와 표현을 잘 이해합니다. 이를 통해 한국어로 작성된 전문 문서를 정확히 분석하고, 사용자의 질문 의도에 맞는 답변을 제공합니다.

Reasoning 모델 + GraphRAG 구축 시나리오

전체 프로세스 개요

이 시스템은 PDF 문서에서 정보를 추출해 벡터와 그래프 두 형태로 Neo4j 데이터베이스에 저장합니다. 이후 사용자의 질문 의도에 따라 가장 적합한 검색 방식을 자동으로 선택해, 보다 정확한 답변을 생성합니다. 프로세스는 다음과 같은 흐름으로 구성됩니다.

[데이터 입력] → 전처리 (PDF 추출 및 분할) → 임베딩 → 지식 그래프 추출 (LLM) / Vector Index 추출 → [Neo4j 저장] → 벡터 인덱스 구축 → 하이브리드 Q&A 파이프라인 → [답변 생성]

0. 라이브러리 세팅

GraphRAG 파이프라인을 구축하기 위해 필요한 필수 라이브러리를 먼저 설치합니다. 아래와 같이 requirements.txt 파일을 생성한 뒤, 필요한 패키지를 한 번에 설치할 수 있습니다.

requests
dotenv
networkx
##
numpy
langchain
langchain-community
langchain-naver
langchain-neo4j
faiss-cpu
##
neo4j
pypdf

이 명령어를 실행하면, requirements.txt에 정의된 모든 라이브러리가 자동으로 설치됩니다.

pip install -r requirements.txt

그 다음 Neo4j를 사용할 수 있는 환경 설정이 필요합니다. 빠르고 간단하게 진행하기 위해, Neo4j Sandbox에서 무료 인스턴스를 생성해 지식 그래프를 구축하겠습니다.

Quote
1. Neo4j Sandbox에서 Blank Sandbox를 생성합니다.

2. 생성된 자격 증명 정보를 이용해 .env 파일을 설정합니다.

NEO4J_URL, NEO4J_USERNAME, 그리고 NEO4J_PASSWORD 정보를 .env 파일에 입력하여 환경 변수로 설정합니다.

3. LangChain에서 제공하는 Neo4jGraph 클래스를 활용해 코드와 Neo4j 간의 연결이 정상적으로 이루어지는지 확인합니다. 이 클래스는 LangChain이 Neo4j와 상호작용하도록 지원하며, 이후 GraphRAG 구축에도 동일하게 사용됩니다. 아래 코드를 실행해 데이터베이스 연결 상태를 확인할 수 있습니다.
import os
from dotenv import load_dotenv
from langchain_neo4j import Neo4jGraph

load_dotenv()

graph = Neo4jGraph(
    url=os.environ["NEO4J_URI"],
    username=os.environ["NEO4J_USERNAME"],
    password=os.environ["NEO4J_PASSWORD"],
)

print("Neo4j에 연결을 시도합니다...")
result = graph.query("RETURN 'Connection successful!' AS message")

if result and result[0]['message'] == 'Connection successful!':
    print("Neo4j 데이터베이스에 성공적으로 연결되었습니다!")
else:
    print("오류: 연결은 되었으나 쿼리 실행에 실패했습니다.")
실행 결과가 아래와 같이 나온다면, 정상적으로 연결된 것입니다.

환경 구성이 완료되면, 본격적인 데이터 준비와 전처리 과정을 시작할 수 있습니다.

1. HCX-007 모델, 데이터 준비와 전처리

다음 단계에서는 PDF 파일에서 텍스트를 추출하고, LLM이 효율적으로 이해할 수 있도록 의미 단위(semantic chunk)로 분할합니다.

PDF 텍스트 추출
pypdf 라이브러리를 활용해 PDF 문서의 모든 페이지에서 텍스트를 읽어옵니다.
의미 기반 분할
클로바 스튜디오의 문단 나누기 API (가이드 보기)를 사용해 문장 간 의미 유사도를 계산하고, 주제 단위로 문단을 자동 분리합니다.

# --- PDF 처리 및 CLOVA Studio Segmentation 로직 ---
def read_pdf_text(pdf_path: str) -> str:
    reader = PdfReader(pdf_path)
    texts = [p.extract_text() or "" for p in reader.pages]
    return "\n\n".join(texts).strip()

def chunk_by_limit(text: str, limit: int) -> List[str]:
    parts = text.split("\n\n")
    batches, cur = [], ""
    for p in parts:
        add = p if not cur else ("\n\n" + p)
        if len(cur) + len(add) <= limit:
            cur += add
        else:
            if cur: batches.append(cur)
            cur = p if len(p) <= limit else ""
            if len(p) > limit:
                print(f"[WARN] A single paragraph of {len(p)} chars is longer than the limit {limit}, it will be chunked bluntly.")
                for i in range(0, len(p), limit):
                    batches.append(p[i:i+limit])
    if cur: batches.append(cur)
    return batches

def clova_segment(text: str, **kwargs) -> List[str]:
    payload = {
        "text": text,
        "alpha": kwargs.get("alpha", -100),
        "segCnt": kwargs.get("segCnt", -1),
        "postProcess": kwargs.get("postProcess", True),
        "postProcessMaxSize": kwargs.get("postProcessMaxSize", 1000),
        "postProcessMinSize": kwargs.get("postProcessMinSize", 200),
    }
    retry, backoff_sec = 3, 1.5
    for attempt in range(1, retry + 1):
        try:
            r = requests.post(SEG_ENDPOINT, headers=_auth_headers(), json=payload, timeout=TIMEOUT)
            data = r.json()
            if r.status_code == 200 and data.get("status", {}).get("code") == "20000":
                # API 응답에서 텍스트 리스트만 추출하여 반환
                return ["\n".join(sents).strip() for sents in data["result"].get("topicSeg", []) if sents]
            raise RuntimeError(f"Segmentation API error: HTTP {r.status_code}, body={data}")
        except Exception as e:
            if attempt == retry: raise e
            time.sleep(backoff_sec * attempt)
    return []

def get_chunks_from_pdf(pdf_path: str) -> List[str]:
    """PDF 파일에서 텍스트를 읽고 CLOVA Studio Segmentation API로 의미 단위 청크를 생성합니다."""
    print(f"Reading PDF: {pdf_path}")
    full_text = read_pdf_text(pdf_path)
    if not full_text:
        raise RuntimeError("Failed to extract text from PDF.")

    batches = chunk_by_limit(full_text, MAX_CHARS_FOR_SEGMENT)
    print(f"Total length={len(full_text):,} -> {len(batches)} batch(es) for segmentation.")

    all_chunks = []
    for i, text_batch in enumerate(batches, 1):
        print(f"Segmenting batch {i}/{len(batches)} (length={len(text_batch):,})...")
        chunks_from_batch = clova_segment(text=text_batch)
        all_chunks.extend(chunks_from_batch)
        print(f" -> Got {len(chunks_from_batch)} chunks.")
    
    return all_chunks

2. 임베딩 및 벡터화

분할된 텍스트 청크를 벡터로 변환해 의미 기반 검색이 가능하도록 준비합니다. 이때 ClovaXEmbeddings를 사용해 각 청크의 의미를 고차원 벡터로 표현합니다.

 clova_embedder = ClovaXEmbeddings(
    model=“clir-emb-dolphin”,
    api_key=os.getenv("CLOVA_API_KEY")
)

3. (Neo4j 활용) 데이터 추출 및 지식 그래프 생성

LLM을 활용해 각 텍스트 청크에서 노드와 관계(Relationship를 추출하고, 이를 Neo4j에 저장하여 지식 그래프를 구축합니다. 이때 Pydantic으로 LLM의 출력 스키마를 미리 정의해 결과를 일관된 구조(JSON)로 받도록 하고, LangChain 체인을 통해 텍스트에서 구조화된 그래프 데이터를 추출하는 체인을 구성합니다.

class Node(BaseModel):
    id: str = Field(description="노드(엔티티)의 이름 또는 ID")
    type: str = Field(description="엔티티의 타입 (예: Person, Organization, Concept)")

class Relationship(BaseModel):
    source: Node = Field(description="관계의 시작 노드")
    target: Node = Field(description="관계의 끝 노드")
    type: str = Field(description="관계의 타입 (예: IS_A, WORKS_FOR, CONTAINS)")

class KnowledgeGraph(BaseModel):
    nodes: List[Node] = Field(description="그래프의 모든 노드 리스트")
    relationships: List[Relationship] = Field(description="그래프의 모든 관계 리스트")

def get_graph_extraction_chain(llm):
    parser = JsonOutputParser(pydantic_object=KnowledgeGraph)
    prompt = ChatPromptTemplate.from_messages([
        ("system", """
        주어진 텍스트에서 핵심 엔티티(노드)와 그들 사이의 관계(엣지)를 식별해야 합니다.
        추출된 모든 노드와 관계를 JSON 형식으로 출력하세요.
        노드 타입은 'Person', 'Organization', 'Concept', 'Technology' 등 일반적인 용어를 사용하세요.
        관계 타입은 'WORKS_FOR', 'DEVELOPS', 'RELATED_TO' 와 같이 대문자와 스네이크 케이스를 사용하세요.
        {format_instructions}
        """),
        ("human", "다음 텍스트에서 지식 그래프를 추출해줘:\n\n{input}")
    ])
    prompt_with_format = prompt.partial(
        format_instructions=parser.get_format_instructions()
    )
    return prompt_with_format | llm | parser

Neo4j에 추출된 노드와 관계를 저장하고, 각 노드가 어떤 텍스트 청크에서 파생되었는지를 함께 연결해 원본 근거를 추적할 수 있도록 구조화합니다.

def ingest_chunks_to_neo4j(chunks: List[str], graph: Neo4jGraph, graph_extraction_chain, embedder):
    graph.query("MATCH (n) DETACH DELETE n")
    print("Cleared existing data from Neo4j.")

    valid_chunks = [chunk for chunk in chunks if chunk and not chunk.isspace()]
    print(f"Total chunks: {len(chunks)}, Valid non-empty chunks: {len(valid_chunks)}")

    for i, chunk_text in enumerate(valid_chunks):
        print(f"--- Processing chunk {i+1}/{len(valid_chunks)} ---")
        
        print("  - Storing chunk for vector search...")
        chunk_embedding = embedder.embed_query(chunk_text)
        graph.query(
            "MERGE (c:Chunk {id: $chunk_id}) SET c.text = $text, c.embedding = $embedding",
            params={
                "chunk_id": f"chunk_{i}",
                "text": chunk_text,
                "embedding": chunk_embedding
            }
        )

        try:
            print("  - Extracting knowledge graph...")
            extracted_data = graph_extraction_chain.invoke({"input": chunk_text})
            nodes_data = extracted_data.get("nodes", [])
            rels_data = extracted_data.get("relationships", [])

            if not (nodes_data or rels_data):
                print("  - No graph elements extracted.")
                continue

            extracted_graph = KnowledgeGraph(nodes=nodes_data, relationships=rels_data)

            for node_obj in extracted_graph.nodes:
                graph.query(
                    "MERGE (n:`{type}` {{id: $id}})".format(type=node_obj.type),
                    params={"id": node_obj.id}
                )
                graph.query(
                    """
                    MATCH (c:Chunk {{id: $chunk_id}})
                    MATCH (n:`{type}` {{id: $node_id}})
                    MERGE (c)-[:CONTAINS]->(n)
                    """.format(type=node_obj.type),
                    params={"chunk_id": f"chunk_{i}", "node_id": node_obj.id}
                )

            for rel_obj in extracted_graph.relationships:
                graph.query(
                    """
                    MATCH (s:`{st}` {{id: $sid}})
                    MATCH (t:`{tt}` {{id: $tid}})
                    MERGE (s)-[:`{rt}`]->(t)
                    """.format(st=rel_obj.source.type, tt=rel_obj.target.type, rt=rel_obj.type),
                    params={"sid": rel_obj.source.id, "tid": rel_obj.target.id}
                )
            print("  - Knowledge graph stored successfully.")

        except Exception as e:
            continue
            
    print("\n✅ PDF chunks ingested into Neo4j.")

4. 벡터 인덱스 구축 및 Neo4j 세팅

의미 기반 검색을 위해 Neo4j 내에 벡터 인덱스를 생성하고, 이를 LangChain의 Neo4jVector와 연결합니다. 이 과정을 통해 임베딩된 텍스트 청크를 효율적으로 검색할 수 있는 환경이 구축됩니다.

def setup_neo4j_vector_index(graph: Neo4jGraph, index_name: str, node_label: str, property_name: str, dimensions: int):
    try:
        graph.query(f"DROP INDEX {index_name} IF EXISTS")
    except Exception as e:
        print(f"Index drop failed: {e}")
    graph.query(
        f"CREATE VECTOR INDEX {index_name} FOR (n:{node_label}) ON (n.{property_name}) OPTIONS {{indexConfig: {{`vector.dimensions`: {dimensions}, `vector.similarity_function`: 'cosine'}}}}"
    )
    print(f"Vector index '{index_name}' created.")

5. 질의응답 파이프라인

사용자의 질문 유형에 따라 그래프 탐색(Graph QA)과 벡터 검색(Vector QA) 중 최적의 방식을 자동으로 선택하는 하이브리드 Q&A 파이프라인을 구성합니다. 이 단계에서는 LangChain의 RetrievalQA와 GraphCypherQAChain을 각각 생성하고, 간단한 키워드 기반 라우팅 로직을 통해 두 체인을 유연하게 전환할 수 있도록 설계합니다.

def get_hcx_llm(model_name: str = "HCX-007"):
    return ChatClovaX(model_name=model_name, temperature=0, request_timeout=120, api_key=CLOVA_API_KEY)

def get_qa_llm(model_name: str = "HCX-007"):
    return ChatClovaX(
        model_name=model_name,
        temperature=0.3,
        request_timeout=120,
        api_key=CLOVA_API_KEY,
        thinking={"effort":"low"},
    )

vector_qa_chain = RetrievalQA.from_chain_type(
        llm=llm_qa, chain_type="stuff", retriever=neo4j_vector_store.as_retriever()
    )

graph_chain = GraphCypherQAChain.from_llm(
    cypher_llm=llm_cypher,
   	qa_llm=llm_qa,
    graph=graph,
    verbose=True,
    allow_dangerous_requests=True,
    cypher_prompt=CYPHER_GENERATION_PROMPT
)

Cypher 기반 동적 프롬프트 설계

HCX-007 모델이 사용자의 질문을 정확한 Cypher 쿼리로 변환할 수 있도록, 그래프 스키마를 참고하는 프롬프트 템플릿을 설계합니다.

CYPHER_GENERATION_TEMPLATE = """
    Task: 너는 사용자의 질문을 Neo4j Cypher 쿼리로 변환하는 전문가이다.
    Instructions:
    - 제공된 그래프 스키마(Graph Schema)만을 사용하여 질문에 답하는 Cypher 쿼리를 생성해야 한다.
    - **오직 Cypher 쿼리만을 ```cypher ... ``` 코드 블록 안에 넣어서 반환해야 한다.**
    - 절대로 코드 블록 외부에 설명이나 주석 등 다른 어떤 텍스트도 포함해서는 안 된다.
    
    # --- 중요: Cypher 문법 규칙 ---
    # 1. 노드의 레이블을 얻으려면 `labels(node)[0]` 을 사용하라.
    # 2. 관계의 타입을 얻으려면, `MATCH` 절에서 관계에 변수(예: `-[r]->`)를 반드시 할당하고 `type(r)` 을 사용하라.
    # 3. MATCH 절에서 나중에 참조할 모든 노드와 관계에는 반드시 변수(예: `(n)`, `(m)`, `-[r]->`)를 할당해야 한다. 
    #    익명 노드 `()` 나 익명 관계 `-[]->` 는 RETURN 절 등에서 사용할 수 없다.
    # 4. 쿼리의 중간 단계에서 변수를 다음으로 넘길 때는 `WITH`를 사용해야 한다. `RETURN`은 쿼리의 가장 마지막에 최종 결과를 출력할 때 오직 한 번만 사용해야 한다.
    # 5. 방향에 관계없이 모든 관계를 찾을 때는 화살표 없는 구문, 즉 `(n)-[r]-(m)` 을 사용해야 한다. 절대 `<-|->` 와 같은 잘못된 구문을 사용해서는 안된다.
    #
    # ❌ 잘못된 쿼리: MATCH (n)-[]->() RETURN type()
    # ✅ 올바른 쿼리: MATCH (n)-[r]->(m) RETURN type(r), labels(m)
    #
    # ❌ 잘못된 구조: MATCH (a)-[r1]->(b) RETURN b.id MATCH (b)-[r2]->(c) RETURN c.id
    # ✅ 올바른 구조: MATCH (a)-[r1]->(b) WITH b MATCH (b)-[r2]->(c) RETURN c.id
    
    # ❌ 잘못된 방향성 쿼리: MATCH (c)<-|->()
    # ✅ 올바른 방향성 쿼리: MATCH (c)-[r]-()

    Graph Schema:
    {schema}

    Question: {question}
    
    Final Answer (only the Cypher code block):
    """
    
    CYPHER_GENERATION_PROMPT = PromptTemplate(
        input_variables=["schema", "question"], template=CYPHER_GENERATION_TEMPLATE
    )

메인 실행 플로우 구현

while True:
        print("\n" + "="*50)
        query = input("질문을 입력하세요 (종료하려면 'exit' 입력): ")
        if query.lower() == 'exit':
            break
        
        try:
            # "누가", "몇 개", "관계" 등 구조적 질문 키워드가 포함되면 그래프 체인 사용
            if any(keyword in query for keyword in ["누가", "몇 개", "어떤 관계", "연결"]):
                print("\n--- Graph Traversal (Structural QA) ---")
                result = graph_chain.invoke({"query": query})
                print(f"답변: {result.get('result', '답변을 생성하지 못했습니다.')}")

            # 그 외의 일반적인 질문은 벡터 검색 체인 사용
            else:
                print("\n--- Vector Search (RAG QA) ---")
                result = vector_qa_chain.invoke({"query": query})
                print(f"답변: {result.get('result', '답변을 생성하지 못했습니다.')}")
                
        except CypherSyntaxError as e:
            print("\n[오류] 쿼리 생성 또는 실행 중 Cypher 문법 오류가 발생했습니다.")
            print("질문을 조금 더 명확하게 하거나 다른 방식으로 질문해보세요.")
            
        except Exception as e:
            print(f"\n[오류] 예측하지 못한 오류가 발생했습니다: {e}")
            print("다른 질문으로 다시 시도해주세요.")

질문 유형별 동작 예시

지금까지의 과정을 통해, GraphRAG가 질문의 유형에 따라 그래프 탐색과 벡터 검색을 유연하게 전환하며 추론하는 구조를 구현하는 과정을 살펴보았습니다. 아래 예시를 살펴보면, 질문의 유형에 따라 그래프 탐색과 벡터 검색이 어떻게 다르게 작동하는지 알 수 있습니다.

GraphRAG 적용한 QA (Structured QA)

Q. 보안 정책 주관 부서와 연결된 부서는 어디이며, 어떤 관계가 있는가?

일반적인 Vector 검색 적용한 QA (RAG QA)

Q. 네이버의 정보보호 목표 달성을 위해 지켜야 할 기본 원칙은?

예를 들어, “보안 정책을 주관하는 부서와 연결된 부서는 어디인가?”처럼 관계를 파악해야 하는 질문에는 GraphRAG이 Neo4j 그래프를 탐색해 부서 간 연결 구조를 제시했습니다. 반면 “네이버의 정보보호 목표 달성을 위해 지켜야 할 기본 원칙은 무엇인가?”와 같은 서술형 질문에는 Vector 검색이 핵심 문장을 찾아 요약하는 데 더 효과적이었습니다. 즉, GraphRAG은 관계형 탐색이 필요한 질문과 일반 텍스트 기반 질의를 구분해 질문의 의도에 가장 적합한 방식으로 답변을 생성하는 구조를 갖추고 있습니다.

마무리 : GraphRAG의 효용성

GraphRAG는 복잡한 관계형 데이터를 다루거나 전문 지식의 근거를 명확히 제시해야 하는 환경에서 특히 유용합니다. 단순한 텍스트 검색으로는 찾기 어려운 데이터 간의 연결과 패턴을 파악할 수 있고, 답변의 근거가 되는 관계를 함께 제시해 신뢰도 높은 결과를 제공합니다. 여러 단계를 거치는 복합적인 질의에서도 그래프 탐색을 통해 논리적 일관성을 유지하고, 신뢰할 수 있는 답변을 제공합니다.

지금까지 GraphRAG 활용하는 방식을 살펴봤습니다. 단순한 검색을 넘어 데이터를 맥락과 의미로 이해하는 GraphRAG 방식을 직접 시도해보세요.

RAG의 활용도를 높일 수 있는 Neo4j 기반 GraphRAG Cookbook

Recommended Posts

CLOVA Studio 운영자