LCEL의 작동 원리

LCEL에서는 왜 프롬프트, 모델, 아웃풋 파서를 |(체인)으로 연결해서 실행할 수 있을까? 모든 클래스가 langchain의 Runnable 클래스를 상속받고 있기 때문입니다.

Runnable을 연결하면 RunnableSequence가 됩니다. 이 시퀀스도 Runnable의 일종입니다.

RunnableSequence를 invoke하면 runnable이 순서대로 invoke됩니다.

Runnable의 실행 방법

Runnable의 실행 방법으로는 3가지가 있습니다:

  • invoke: 동기 실행
  • stream: 스트리밍 실행
  • batch: 배치 실행

비동기로 실행할 수 있는 방법으로도 3가지가 제공됩니다:

  • ainvoke: 비동기 실행
  • astream: 비동기 스트리밍
  • abatch: 비동기 배치

Stream 예제

chain = prompt | model | output_parser

for chunk in chain.stream({"input": "..."}):
    print(chunk, end = "", flush = True)

Batch 예제

chain = prompt | model | output_parser

output = chain.batch([{"input":"..."}, {"input":"..."}])
print(output)

LCEL 내부 구현

LCEL은 어떻게 구현되었길래 체인으로 모델과 프롬프트를 연결할 수 있을까요? __or__과 __ror__가 이렇게 구현되어 있습니다:

def __or__(self,
    other: Union[Runnable[Any, Other],
                Callable[[Any], Other]],
                Callable[Iterator[Any], Iterator[Other]],
                Mapping[str, Union[Runnable[Any,Other]], Callable[[Any],Other],Any]) -> RunnableSerializable[Input, Other]:
        return RunnableSequence(first=self, last=coerce_to_runnable(other))

def __ror__(self,
    other: Union[Runnable[Other, Any],
                Callable[[Other], Any]],
                Callable[Iterator[Other], Iterator[Any]],
                Mapping[str, Union[Runnable[Other,Any]], Callable[[Other],Any],Any]) -> RunnableSerializable[Other, Output]:
        return RunnableSequence(first=coerce_to_runnable(other), last=self)

이 연산자들을 통해 체인을 오버로드할 수 있습니다.

각각의 러너블을 실행(호출)하는 방법이 다르면, 이 컴포넌트들을 연결하는 처리를 개별적으로 구현해야하는데, LCEL을 사용하면 모든 컴포넌트를 통일된 인터페이스로 호출할 수 있게 됩니다.

다양한 러너블 연결하기

1. 두개의 체인 연결하기

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

model = ChatOpenAI(model = "gpt-4o-mini", temperature = 0)
output_parser = StrOutputParser()

## 체인 1 : 답변을 단계적으로 생성하기
cot_prompt = ChatPromptTemplate.from_messages([
    ("system", "사용자의 질문에 단계적으로 답변하세요"),
    ("user", "{input}"),
])

cot_chain = cot_prompt | model | output_parser

## 체인 2: 결론 추출하기
summary_prompt = ChatPromptTemplate.from_messages([
    ("system", "단계적으로 생각한 답변에서 결론을 추출하세요"),
    ("user", "{text}"),
])

summary_chain = summary_prompt | model | output_parser

## 체인 3: 체인 연결하기
chain = cot_chain | summary_chain

## 체인 실행하기
output = chain.invoke({"input": "오늘 날씨가 어때?"})
print(output)

주의: 입력 타입과 출력 타입의 일관성을 유지해야 합니다!

임의의 함수를 러너블로 만들기: RunnableLambda

어떤 변환을 적용하거나 추가 처리를 하는 함수를 러너블로 만들면 체인간 변환을 수행하는 기능을 구현할 수 있습니다.

1. 기본 구현 방식

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableLambda
from langchain_openai import ChatOpenAI

prompt = ChatPromptTemplate.from_messages([
    ("system", "사용자의 질문에 단계적으로 답변하세요"),
    ("user", "{input}"),
])
model = ChatOpenAI(model = "gpt-4o-mini", temperature = 0)
output_parser = StrOutputParser()

# 임의의 함수를 러너블로 만들기
def add_prefix(text: str) -> str:
    return "결론: " + text

add_prefix_runnable = RunnableLambda(add_prefix)

# 체인 구성
chain = prompt | model | output_parser | add_prefix_runnable

# 체인 실행
output = chain.invoke({"input": "오늘 날씨가 어때?"})
print(output)

2. 데코레이터를 사용한 구현 방식

from langchain_core.runnables import chain

@chain
def add_prefix(text: str) -> str:
    return "결론: " + text

chain = prompt | model | output_parser | add_prefix

output = chain.invoke({"input": "오늘 날씨가 어때?"})
print(output)

3. 암시적으로 생성하기

def add_prefix(text: str) -> str:
    return "결론: " + text

chain = prompt | model | output_parser | add_prefix

output = chain.invoke({"input": "오늘 날씨가 어때?"})
print(output)

Stream 처리 시 주의사항

사용자 함수를 사용할때 stream으로 호출하면 점진적으로 출력되지 않고 처리가 완전히 끝난 시점에 한꺼번에 출력됩니다. 사용자 정의함수는 입력을 한꺼번에 처리하도록 되어있기 때문입니다.

점진적으로 처리하기 위해 제너레이터 함수를 사용해야 합니다:

def upper(input: Iterator[str]) -> Iterator[str]:
    for text in input:
        yield text.upper()

여러 러너블을 병렬로 연결하기

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

model = ChatOpenAI(model = "gpt-4o-mini", temperature = 0)
output_parser = StrOutputParser()

pros_prompt = ChatPromptTemplate.from_messages([
    ("system", "사용자의 진술에서 장점을 찾아서 긍정적으로 답변하세요."),
    ("user", "{input}"),
])

pros_chain = pros_prompt | model | output_parser

cons_prompt = ChatPromptTemplate.from_messages([
    ("system", "사용자의 진술에서 단점을 찾아서 부정적으로 답변하세요."),
    ("user", "{input}"),
])

cons_chain = cons_prompt | model | output_parser

## 병렬 체인 구성
chain = RunnableParallel(
    {"장점": pros_chain},
    {"단점": cons_chain},
)

## 병렬 체인 실행
output = chain.invoke({"input": "오늘 날씨가 어때?"})
print(output)

# 요약 체인 구성
summary_prompt = ChatPromptTemplate.from_messages([
    ("system", "장점과 단점을 요약하세요."),
    ("user", "{장점} {단점}"),
])

summary_chain = (RunnableParallel(
    {"장점": pros_chain},
    {"단점": cons_chain},
) | summary_prompt | model | output_parser
)

## 암시적으로 병렬 체인 구성하기
summary_chain2 = (
    {"장점": pros_chain, "단점": cons_chain} | summary_prompt | model | output_parser
)

Item Getter 사용

딕셔너리에서 값을 추출하는 함수를 만들 수 있습니다:

from operator import itemgetter

topic_getter = itemgetter("장점")
topic = topic_getter({"장점":"맛있다."})
print(topic)
# > 맛있다.

# 체인 예시
synt_prompt = ChatPromptTemplate.from_messages([
    ("system", "사용자의 진술에서 {topic}에 대한 장점과 단점을 찾아서 긍정적으로 답변하세요."),
    ("user", "장점 :{장점}\n단점 :{단점}"),
])

synt_chain = {
    "장점": pros_chain,
    "단점": cons_chain,
    "topic": itemgetter("topic"),
} | synt_prompt | model | output_parser

output = synt_chain.invoke({"topic": "회사를 다니고 있습니다."})

RunnablePassthrough 활용

RAG 처리 구현

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

prompt = ChatPromptTemplate.from_template('''
                                           다음 문맥만을 고려하여 질문에 대답하세요.
                                           문맥: "{context}"
                                           질문: "{question}"
                                           ''')

model = ChatOpenAI(model = "gpt-4o-mini", temperature = 0)

from langchain_community.retrievers import TravilySearchAPIRetriever

retriever = TravilySearchAPIRetriever(
    api_key = os.getenv("TRAVILY_API_KEY"),
    max_results = 2,
    k=3)

from langchain_core.runnables import RunnablePassthrough

chain = (
    {"context": retriever, "question": RunnablePassthrough()} | prompt | model | output_parser
)

output = chain.invoke({"question": "오늘 날씨가 어때?"})
print(output)

러너블 체인에 값 추가하기: assign

import pprint

chain = {
    "question": RunnablePassthrough(),
    "context": retriever,
} | RunnablePassthrough.assign(
    answer=prompt | model | StrOutputParser()
)

output = chain.invoke({"question": "오늘 날씨가 어때?"})
pprint(output)

## assign은 인스턴스 메서드로도 제공됩니다
chain = RunnableParallel({
    "question": RunnablePassthrough(),
    "context": retriever,
}).assign(answer=prompt | model | StrOutputParser())

output = chain.invoke({"question": "오늘 날씨가 어때?"})
pprint(output)

Pick으로 일부 값만 선택

chain = RunnableParallel({
    "question": RunnablePassthrough(),
    "context": retriever,
}).assign(answer=prompt | model | StrOutputParser()
          ).pick("context", "answer")

output = chain.invoke({"question": "오늘 날씨가 어때?"})
pprint(output)

중간값 출력: astream_events

chain = (
    {"context": retriever, "question": RunnablePassthrough()} | prompt | model | StrOutputParser()
)

async for event in chain.astream_events("서울의 현재 날씨는?", version = "v2"):
    event_kind = event["event"]
    if event_kind == "on_retriever_end":
        print("검색 결과:")
        documents = event["data"]["output"]
        for document in documents:
            print(document)

    elif event_kind == "on_parser_start":
        print("출력 파서 시작")

    elif event_kind == "on_parser_stream":
        chunk = event["data"]["chunk"]
        print(chunk, end = "", flush = True)

Chat History 관리

from langchain_community.chat_message_histories import SQLChatMessageHistory

def respond(session_id: str, human_message: str) -> str:
    chat_message_history = SQLChatMessageHistory(
        session_id = session_id,
        connection = "sqlite:///sqlite.db",
    )
    messages = chat_message_history.get_messages()

    ai_message = chain.invoke({
        "chat_history": messages,
        "human_message": human_message,
    })

    chat_message_history.add_user_message(human_message)
    chat_message_history.add_ai_message(ai_message)

    return ai_message

# 호출
from uuid import uuid4

session_id = uuid4().hex
output1 = respond(session_id=session_id, human_message="안녕하세요. 제 이름은 나뭇잎입니다.")
print(output1)

output2 = respond(session_id=session_id, human_message="내 이름이 뭘까?")
print(output2)

지원하는 데이터베이스

SQLite 말고 다른 데이터베이스의 통합도 제공합니다:

  • 인메모리
  • SQLAlchemy가 지원하는 각종 관계형 데이터베이스
  • Redis
  • DynamoDB
  • CosmosDB
  • Momento 등

메모리

대화 이력에 대한 고급 처리를 구현하고 싶은 경우 메모리를 사용합니다. 예를 들어 최근 k개의 대화 이력만 포함하고 싶은 경우. ConversationBufferWindowMemory나 ConversationSummaryMemory를 해당 컴포넌트로 사용할 수 있습니다.

LangServe

LangChain의 러너블을 간편하게 REST API로 만들기 위한 패키지입니다.

📚 추가로 알아볼 내용

1. 고급 Runnable 패턴들

RunnableGenerator (스트리밍 생성기):

from langchain_core.runnables import RunnableGenerator

def streaming_splitter(input: Iterator[str]) -> Iterator[str]:
    buffer = ""
    for chunk in input:
        buffer += chunk
        # 문장 단위로 분할하여 yield
        while '. ' in buffer:
            sentence, buffer = buffer.split('. ', 1)
            yield sentence + '. '

    if buffer:
        yield buffer

streaming_chain = model | RunnableGenerator(streaming_splitter)

RunnableRetry (재시도 로직):

from langchain_core.runnables import RunnableRetry

retry_chain = RunnableRetry(
    bound=model,
    max_attempt_number=3,
    wait_exponential_jitter=True,
    stop_after_delay=30
)

RunnableWithMessageHistory (대화 이력 관리):

from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import SQLChatMessageHistory

def get_session_history(session_id: str):
    return SQLChatMessageHistory(session_id, "sqlite:///memory.db")

chain_with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="chat_history",
)

2. 복잡한 라우팅 전략

Multi-Modal Routing:

from typing import Literal

class RouteInput(BaseModel):
    query: str
    data_type: Literal["text", "image", "code"] = "text"

def route_by_type(input: RouteInput):
    if input.data_type == "image":
        return vision_chain
    elif input.data_type == "code":
        return code_analysis_chain
    else:
        return general_chain

routing_chain = RunnableLambda(route_by_type)

Semantic Routing:

from langchain_community.utils.math import cosine_similarity

def semantic_router(query: str, route_embeddings: dict):
    query_embedding = embeddings.embed_query(query)

    similarities = {}
    for route, embedding in route_embeddings.items():
        sim = cosine_similarity([query_embedding], [embedding])[0][0]
        similarities[route] = sim

    best_route = max(similarities, key=similarities.get)
    return route_chains[best_route]

3. 고급 병렬 처리 패턴

조건부 병렬 실행:

def conditional_parallel(input_data):
    base_tasks = {"summary": summary_chain}

    # 조건에 따라 추가 작업 결정
    if len(input_data.get("text", "")) > 1000:
        base_tasks["keywords"] = keyword_chain

    if input_data.get("analyze_sentiment", False):
        base_tasks["sentiment"] = sentiment_chain

    return RunnableParallel(base_tasks).invoke(input_data)

단계적 병렬 처리:

# Phase 1: 기본 분석
phase1 = RunnableParallel({
    "entities": entity_extraction_chain,
    "classification": classification_chain
})

# Phase 2: Phase 1 결과를 기반으로 한 고급 분석
def phase2_router(phase1_results):
    tasks = {}

    if phase1_results["classification"] == "technical":
        tasks["tech_analysis"] = technical_chain

    if len(phase1_results["entities"]) > 5:
        tasks["entity_relations"] = relation_chain

    return RunnableParallel(tasks).invoke(phase1_results)

two_phase_chain = phase1 | RunnableLambda(phase2_router)

4. 메모리 최적화 고급 기법

청크별 스트림 처리:

def chunked_processing(large_input: str, chunk_size: int = 1000):
    """대용량 텍스트를 청크별로 스트림 처리"""
    chunks = [large_input[i:i+chunk_size]
              for i in range(0, len(large_input), chunk_size)]

    for chunk in chunks:
        yield chain.stream({"input": chunk})

# 사용법
for chunk_result in chunked_processing(huge_document):
    for token in chunk_result:
        print(token, end="", flush=True)

메모리 사용량 모니터링:

import psutil
import os

def memory_monitor(func):
    def wrapper(*args, **kwargs):
        process = psutil.Process(os.getpid())
        initial_memory = process.memory_info().rss / 1024 / 1024  # MB

        result = func(*args, **kwargs)

        final_memory = process.memory_info().rss / 1024 / 1024
        print(f"Memory usage: {final_memory - initial_memory:.2f} MB")

        return result
    return wrapper

@memory_monitor
def process_large_chain(input_data):
    return chain.invoke(input_data)

🔍 학습하면서 알게 된 점

1. astream_events의 실제 활용 방법

async def detailed_streaming_analysis():
    events = []
    async for event in chain.astream_events("분석할 텍스트", version="v2"):
        event_type = event["event"]

        if event_type == "on_chat_model_start":
            print("🚀 LLM 호출 시작")
            events.append(("llm_start", event["data"]))

        elif event_type == "on_chat_model_stream":
            token = event["data"]["chunk"].content
            print(token, end="", flush=True)

        elif event_type == "on_retriever_end":
            docs = event["data"]["output"]
            print(f"\n📚 검색된 문서 수: {len(docs)}")

        elif event_type == "on_chain_end":
            print("\n✅ 체인 완료")

    return events

핵심 인사이트:

  • astream_events는 디버깅과 사용자 경험 개선에 핵심적
  • 각 컴포넌트의 실행 시간과 결과를 실시간 추적 가능
  • 사용자에게 진행 상황을 시각적으로 보여줄 수 있음

2. RunnablePassthrough의 숨겨진 활용법

# 1. 조건부 데이터 전달
def conditional_passthrough(data):
    if data.get("debug"):
        print(f"Debug info: {data}")
    return data

debug_chain = RunnableLambda(conditional_passthrough) | main_chain

# 2. 데이터 변환과 원본 보존
transform_and_keep = RunnableParallel({
    "original": RunnablePassthrough(),
    "processed": preprocessing_chain,
    "metadata": RunnableLambda(lambda x: {"timestamp": time.time()})
})

3. assign()과 pick()의 고급 활용

# 복잡한 데이터 플로우 관리
complex_chain = (
    RunnableParallel({
        "user_input": RunnablePassthrough(),
        "context": retriever,
    })
    .assign(
        # 컨텍스트 기반 사전 분석
        preliminary_analysis=lambda x: analyze_context(x["context"])
    )
    .assign(
        # 사전 분석 기반 프롬프트 선택
        selected_prompt=lambda x: select_prompt(x["preliminary_analysis"]),
        # 메타데이터 추가
        processing_metadata=lambda x: {
            "context_length": sum(len(doc.page_content) for doc in x["context"]),
            "analysis_type": x["preliminary_analysis"]["type"]
        }
    )
    .assign(
        # 최종 답변 생성
        answer=lambda x: x["selected_prompt"].format_prompt(
            context=format_context(x["context"]),
            question=x["user_input"]
        ) | model | StrOutputParser()
    )
    .pick("user_input", "answer", "processing_metadata")  # 필요한 것만 선택
)

4. 에러 복구 전략의 실제 구현

class GracefulDegradationChain:
    def __init__(self, primary_chain, fallback_chain, simple_fallback):
        self.primary = primary_chain
        self.fallback = fallback_chain
        self.simple = simple_fallback

    def invoke(self, input_data):
        # 1차 시도: 주요 체인
        try:
            return self.primary.invoke(input_data)
        except Exception as e1:
            print(f"Primary chain failed: {e1}")

            # 2차 시도: 폴백 체인
            try:
                return self.fallback.invoke(input_data)
            except Exception as e2:
                print(f"Fallback chain failed: {e2}")

                # 3차 시도: 간단한 응답
                try:
                    return self.simple.invoke(input_data)
                except Exception as e3:
                    # 최종 안전장치
                    return {
                        "answer": "죄송합니다. 일시적인 오류가 발생했습니다.",
                        "error": True,
                        "original_errors": [str(e1), str(e2), str(e3)]
                    }

# 사용법
resilient_chain = GracefulDegradationChain(
    primary_chain=complex_rag_chain,
    fallback_chain=simple_qa_chain,
    simple_fallback=RunnableLambda(lambda x: {"answer": "기본 응답을 제공합니다."})
)

5. 성능 최적화의 실전 경험

배치 처리 최적화:

def optimized_batch_processing(inputs, batch_size=10):
    """메모리 효율적인 배치 처리"""
    results = []

    for i in range(0, len(inputs), batch_size):
        batch = inputs[i:i+batch_size]

        # 배치별 처리
        batch_results = chain.batch(batch)
        results.extend(batch_results)

        # 메모리 정리 (선택적)
        if i % 100 == 0:  # 100개 배치마다
            import gc
            gc.collect()

    return results

캐싱 전략:

import hashlib
from functools import wraps

def smart_cache(ttl=3600):
    cache = {}

    def decorator(func):
        @wraps(func)
        def wrapper(input_data):
            # 입력 해시 생성
            input_str = str(sorted(input_data.items()) if isinstance(input_data, dict) else input_data)
            cache_key = hashlib.md5(input_str.encode()).hexdigest()

            # 캐시 확인
            if cache_key in cache:
                result, timestamp = cache[cache_key]
                if time.time() - timestamp < ttl:
                    return result

            # 새로 계산
            result = func(input_data)
            cache[cache_key] = (result, time.time())

            # 캐시 크기 관리 (LRU 방식)
            if len(cache) > 1000:
                oldest_key = min(cache, key=lambda k: cache[k][1])
                del cache[oldest_key]

            return result
        return wrapper
    return decorator

@smart_cache(ttl=1800)
def cached_chain_invoke(input_data):
    return expensive_chain.invoke(input_data)

6. 프로덕션 환경에서의 교훈

모니터링 통합:

from datetime import datetime
import json

class ProductionChainWrapper:
    def __init__(self, chain, logger=None):
        self.chain = chain
        self.logger = logger

    def invoke(self, input_data):
        start_time = datetime.now()

        try:
            result = self.chain.invoke(input_data)

            # 성공 로그
            duration = (datetime.now() - start_time).total_seconds()
            self._log_success(input_data, result, duration)

            return result

        except Exception as e:
            duration = (datetime.now() - start_time).total_seconds()
            self._log_error(input_data, e, duration)
            raise

    def _log_success(self, input_data, result, duration):
        log_data = {
            "timestamp": datetime.now().isoformat(),
            "status": "success",
            "duration": duration,
            "input_tokens": self._estimate_tokens(str(input_data)),
            "output_tokens": self._estimate_tokens(str(result))
        }

        if self.logger:
            self.logger.info(json.dumps(log_data))

    def _estimate_tokens(self, text):
        # 간단한 토큰 추정 (실제로는 tiktoken 사용 권장)
        return len(text.split()) * 1.3

이러한 고급 기법들은 실제 프로덕션 환경에서 안정적이고 효율적인 LangChain 애플리케이션 구축에 필수적입니다.