RAG 2.0: 기업 지식관리의 혁신 - 단순 챗봇을 넘어 지능형 조직 메모리로

사용자 질문
  ↓
벡터 데이터베이스에서 유사 문서 검색
  ↓
검색된 문서 + 사용자 질문을 프롬프트에 포함
  ↓
LLM이 답변 생성

사용자 질문
  ├─→ 키워드 검색 (BM25)
  ├─→ 벡터 검색 (의미 기반)
  ├─→ 지식 그래프 쿼리 (관계 기반)
  ├─→ 메타데이터 필터링 (속성 기반)
  └─→ 재정렬(Re-ranking) 및 통합
        ↓
      맥락 충분한 검색 결과
        ↓
      LLM이 답변 생성 (근거 포함)

from weaviate import Client
from weaviate.auth import AuthApiKey
import os

# Weaviate 클라이언트 초기화
client = Client(
    url="https://your-cluster.weaviate.network",
    auth_client_secret=AuthApiKey(api_key=os.environ["WEAVIATE_API_KEY"])
)

def hybrid_search(query, query_type="questions"):
    # 하이브리드 검색: BM25 (키워드) + 벡터 (의미)
    response = client.query\
        .get(query_type, ["document", "content", "source", "confidence"])\
        .with_hybrid(query=query, alpha=0.7)\
        .with_where({
            "path": ["createdAt"],
            "operator": "GreaterThan",
            "valueDate": "2024-01-01T00:00:00Z"
        })\
        .with_limit(10)\
        .do()

    return response["data"]["Get"][query_type]

# 사용 예제
results = hybrid_search("2026년 분기별 매출 목표는?")
for result in results:
    print(f"문서: {result['document']}")
    print(f"신뢰도: {result['confidence']}")
    print(f"출처: {result['source']}\n")

개념 (Nodes):
  - 회사: "ABC 기업"
  - 부서: "개발팀", "마케팅팀", "영업팀"
  - 제품: "Product A", "Product B"
  - 사람: "김철수 이사", "이영희 팀장"

관계 (Edges):
  - "ABC 기업" --관리--> "개발팀"
  - "개발팀" --만드는--> "Product A"
  - "이영희 팀장" --소속--> "개발팀"
  - "김철수 이사" --감독--> "개발팀"

MATCH (company:Company {name: "ABC 기업"})-[:manages]->(dept:Department)
      -[:owns]->(product:Product),
      (person:Person)-[:leadsTeam]->(dept)
WHERE product.status = "Active"
RETURN company.name, dept.name, product.name, person.name
ORDER BY product.launchDate DESC

from langchain.document_loaders import PDFPlumberLoader
from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage
import base64

def process_mixed_media(pdf_path):
    loader = PDFPlumberLoader(pdf_path)
    documents = loader.load()

    multimodal_content = []

    for doc in documents:
        # 텍스트 추출
        text_content = doc.page_content

        # 이미지 및 테이블 추출 (PDFPlumber의 이미지 처리)
        images = doc.metadata.get('images', [])
        tables = doc.metadata.get('tables', [])

        multimodal_content.append({
            'type': 'text',
            'content': text_content
        })

        for img in images:
            multimodal_content.append({
                'type': 'image',
                'content': img
            })

        for table in tables:
            multimodal_content.append({
                'type': 'table',
                'content': table
            })

    return multimodal_content

# GPT-4V를 사용한 멀티모달 분석
def analyze_with_vision(multimodal_content):
    client = ChatOpenAI(model="gpt-4-vision-preview")

    messages = [
        SystemMessage(content="당신은 기업 문서 분석 전문가입니다. 제공된 텍스트, 이미지, 테이블을 종합적으로 분석하세요."),
        HumanMessage(
            content=[
                {
                    "type": "text",
                    "text": "이 문서에서 가장 중요한 재무 지표는 무엇인가요?"
                },
                *[{"type": item['type'], "data": item['content']}
                  for item in multimodal_content[:3]]
            ]
        )
    ]

    response = client.invoke(messages)
    return response.content

┌─────────────────────────────────────────────────┐
│          사용자 인터페이스                        │
│  (웹 애플리케이션, 모바일, 음성 인터페이스)      │
└──────────────┬──────────────────────────────────┘
               │
┌──────────────▼──────────────────────────────────┐
│         오케스트레이션 계층                      │
│  (LangChain / LlamaIndex Agents)                 │
└──────────────┬──────────────────────────────────┘
               │
      ┌────────┼────────┐
      │        │        │
┌─────▼──┐ ┌──▼────┐ ┌─▼──────┐
│LLM    │ │검색   │ │도구    │
│엔진   │ │엔진   │ │통합    │
└────────┘ └───────┘ └────────┘
      │        │        │
      └────────┼────────┘
               │
      ┌────────▼────────────────┐
      │    데이터 계층           │
      │                         │
      │ ┌─────────────────────┐ │
      │ │벡터 DB (Pinecone)  │ │
      │ │키워드 검색 (ES)    │ │
      │ │그래프 DB (Neo4j)   │ │
      │ │메타 저장소 (SQL)   │ │
      │ └─────────────────────┘ │
      │                         │
      │ ┌─────────────────────┐ │
      │ │문서 소스             │ │
      │ │ - 내부 wiki         │ │
      │ │ - 이메일 아카이브   │ │
      │ │ - 보고서 라이브러리 │ │
      │ │ - 실시간 데이터     │ │
      │ └─────────────────────┘ │
      └──────────────────────────┘

from llama_index.core import Document, VectorStoreIndex
from llama_index.vector_stores.weaviate import WeaviateVectorStore
from llama_index.core.storage import StorageContext
from llama_index.embeddings.openai import OpenAIEmbedding
import weaviate

# Weaviate 클라이언트 설정
client = weaviate.Client("http://localhost:8080")

# 벡터 스토어 설정
vector_store = WeaviateVectorStore(client=client)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
embed_model = OpenAIEmbedding()

# 문서 로드 및 인덱싱
documents = [
    Document(
        text="2026년 분기별 매출은 1Q: 50억, 2Q: 52억, 3Q: 48억, 4Q: 55억으로 예상됩니다.",
        metadata={"source": "재무_계획_2026", "department": "재무", "date": "2026-03-16"}
    ),
    Document(
        text="신제품 출시는 4월 15일로 예정되어 있으며, 마케팅 예산은 10억원이 할당되었습니다.",
        metadata={"source": "제품_로드맵", "department": "마케팅", "date": "2026-03-01"}
    )
]

# 인덱스 생성 (메타데이터 필터링 포함)
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    embed_model=embed_model
)

# 쿼리 엔진 생성
query_engine = index.as_query_engine(
    filters={
        "where": {
            "path": ["metadata.department"],
            "operator": "Equal",
            "valueString": "재무"
        }
    }
)

response = query_engine.query("올해 분기별 매출 예상은?")
print(response)

from langchain.agents import Tool, initialize_agent, AgentType
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import Pinecone
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.memory import ConversationBufferMemory
import pinecone

# Pinecone 초기화
pinecone.init(api_key="YOUR_API_KEY", environment="YOUR_ENV")
index = pinecone.Index("knowledge-base")

# 벡터 스토어 설정
embeddings = OpenAIEmbeddings()
vectorstore = Pinecone(index, embeddings.embed_query, "text")

# 검색 도구 정의
def search_knowledge_base(query):
    results = vectorstore.similarity_search(query, k=5)
    return "\n".join([doc.page_content for doc in results])

# 비즈니스 룰 도구 정의
def check_business_rules(query):
    rules = {
        "할인율": "최대 20% 이하만 가능",
        "계약금": "최소 계약금은 100만원",
        "승인권한": "5000만원 이상은 CFO 승인 필요"
    }
    for rule, value in rules.items():
        if rule.lower() in query.lower():
            return value
    return "해당 비즈니스 룰을 찾을 수 없습니다."

# 도구 등록
tools = [
    Tool(
        name="Knowledge Base Search",
        func=search_knowledge_base,
        description="조직의 지식베이스에서 관련 정보를 검색합니다."
    ),
    Tool(
        name="Business Rules",
        func=check_business_rules,
        description="비즈니스 정책 및 규칙을 조회합니다."
    )
]

# 에이전트 초기화
memory = ConversationBufferMemory(memory_key="chat_history")
llm = ChatOpenAI(temperature=0, model="gpt-4")

agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.OPENAI_FUNCTIONS,
    memory=memory,
    verbose=True
)

# 에이전트 실행
response = agent.run(
    "고객에게 15% 할인을 제공할 수 있나요? "
    "그리고 우리 회사의 할인 정책은 무엇인가요?"
)
print(response)

from ragas.metrics import (
    context_precision,
    context_recall,
    faithfulness,
    answer_relevancy
)
from ragas import evaluate

# 평가 데이터셋
eval_dataset = {
    "question": [
        "2026년 분기별 매출은?",
        "신제품 출시 일정은?",
        "마케팅 예산은 얼마인가?"
    ],
    "ground_truth": [
        "1Q: 50억, 2Q: 52억, 3Q: 48억, 4Q: 55억",
        "4월 15일",
        "10억원"
    ],
    "answer": [
        # RAG 시스템의 답변들
    ],
    "contexts": [
        # 검색된 컨텍스트들
    ]
}

# RAGAS를 사용한 평가
results = evaluate(
    eval_dataset,
    metrics=[
        context_precision,      # 검색된 문서의 관련성
        context_recall,         # 필요한 정보 포함 여부
        faithfulness,          # 생성된 답변이 컨텍스트를 따르는 정도
        answer_relevancy       # 답변이 질문과 관련있는 정도
    ]
)

print(f"Context Precision: {results['context_precision']:.3f}")
print(f"Context Recall: {results['context_recall']:.3f}")
print(f"Faithfulness: {results['faithfulness']:.3f}")
print(f"Answer Relevancy: {results['answer_relevancy']:.3f}")

# 사용자 질문을 자동으로 확장
def expand_query(original_query):
    expansion_prompt = f"""
    다음 질문을 3개의 다른 표현으로 바꾸세요:
    원본: {original_query}

    확장된 질문들:
    """
    # LLM을 사용한 쿼리 확장
    expanded = llm.invoke(expansion_prompt)
    return [original_query] + expanded.split('\n')

# 1차: BM25로 후보 검색
# 2차: 교차 인코더로 재정렬
# 3차: 유사도 기반 필터링

from sentence_transformers import CrossEncoder

cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')

def rerank_results(query, candidates):
    pairs = [[query, doc] for doc in candidates]
    scores = cross_encoder.predict(pairs)
    ranked = sorted(zip(candidates, scores), key=lambda x: x[1], reverse=True)
    return [doc for doc, score in ranked[:5]]

Diagram showing RAG 2.0 architecture with hybrid search (keyword and vector paths), knowledge graphs, multiple data sources, and LLM integration. Include icons for different data types (documents, tables, images), vector/graph databases, and the final response generation. Modern tech illustration style with blues and purples.