🔗 LangChain 완벽 가이드: AI 애플리케이션 개발의 새로운 패러다임

김민범·2025년 7월 2일

LangChain, AI, Python, RAG, 프레임워크

🤖 이 글은 Claude Desktop과 MCP를 활용하여 AI가 자동으로 작성한 LangChain 가이드입니다!

🔗 LangChain이란?

LangChain은 LLM(Large Language Model)을 활용한 애플리케이션 개발을 위한 강력한 프레임워크입니다. 복잡한 AI 워크플로우를 간단하고 모듈화된 방식으로 구축할 수 있게 해줍니다.

⭐ 핵심 개념

LangChain의 주요 구성 요소를 이해하는 것이 중요합니다:

Chains: 여러 구성 요소를 연결하는 파이프라인
Prompts: LLM에 전달할 프롬프트 템플릿 관리
Memory: 대화 기록과 컨텍스트 유지
Agents: 자율적으로 도구를 사용하는 AI 에이전트
Tools: 외부 API나 기능과의 연동

🚀 LangChain 시작하기

설치 및 기본 설정

# LangChain 설치
pip install langchain langchain-openai

# 추가 의존성 (선택사항)
pip install langchain-community chromadb faiss-cpu

기본 사용법

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

# LLM 초기화
llm = ChatOpenAI(temperature=0.7)

# 프롬프트 템플릿 생성
prompt = ChatPromptTemplate.from_template(
    "다음 주제에 대해 간단히 설명해주세요: {topic}"
)

# 체인 구성
chain = prompt | llm | StrOutputParser()

# 실행
result = chain.invoke({"topic": "양자컴퓨팅"})
print(result)

🔧 LangChain의 핵심 구성 요소

1. 프롬프트 템플릿 (Prompt Templates)

from langchain.prompts import PromptTemplate

# 기본 프롬프트 템플릿
template = """
당신은 {role}입니다.
다음 질문에 {style} 스타일로 답변해주세요:

질문: {question}
답변:"""

prompt = PromptTemplate(
    input_variables=["role", "style", "question"],
    template=template
)

# 사용 예시
formatted_prompt = prompt.format(
    role="데이터 사이언티스트",
    style="전문적이고 친근한",
    question="머신러닝과 딥러닝의 차이점은?"
)

2. 메모리 시스템 (Memory)

from langchain.memory import ConversationBufferWindowMemory
from langchain.chains import ConversationChain

# 대화 기록 메모리 (최근 5개 메시지만 유지)
memory = ConversationBufferWindowMemory(k=5)

# 대화 체인 생성
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# 대화 진행
response1 = conversation.predict(input="안녕하세요!")
response2 = conversation.predict(input="제 이름은 김민범입니다.")
response3 = conversation.predict(input="제 이름이 뭐라고 했죠?")

3. 도구와 에이전트 (Tools & Agents)

from langchain.agents import create_openai_functions_agent, AgentExecutor
from langchain.tools import DuckDuckGoSearchRun
from langchain_community.tools import WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper

# 도구 정의
search = DuckDuckGoSearchRun()
wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())

tools = [search, wikipedia]

# 에이전트 생성
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 에이전트 실행
result = agent_executor.invoke({
    "input": "2024년 노벨물리학상 수상자에 대해 알려주세요"
})

📚 RAG (Retrieval-Augmented Generation) 구현

RAG는 LangChain의 가장 강력한 기능 중 하나입니다:

from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA

# 1. 문서 로드 및 분할
loader = TextLoader("document.txt")
documents = loader.load()

text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# 2. 임베딩 및 벡터 스토어 생성
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)

# 3. RAG 체인 구성
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

# 4. 질의응답 실행
query = "문서에서 주요 핵심 내용이 무엇인가요?"
result = qa_chain.invoke({"query": query})

🎯 실무 활용 예시

1. 고객 서비스 챗봇

class CustomerServiceBot:
    def __init__(self):
        self.llm = ChatOpenAI(temperature=0.3)
        self.memory = ConversationBufferWindowMemory(k=10)
        
        self.prompt = ChatPromptTemplate.from_template("""
        당신은 친절한 고객 서비스 담당자입니다.
        고객의 문의에 정확하고 도움이 되는 답변을 제공하세요.
        
        대화 기록: {chat_history}
        고객 문의: {human_input}
        
        답변:""")
        
        self.chain = self.prompt | self.llm | StrOutputParser()
    
    def respond(self, user_input):
        chat_history = self.memory.chat_memory.messages
        response = self.chain.invoke({
            "chat_history": chat_history,
            "human_input": user_input
        })
        
        self.memory.chat_memory.add_user_message(user_input)
        self.memory.chat_memory.add_ai_message(response)
        
        return response

2. 문서 요약 시스템

from langchain.chains.summarize import load_summarize_chain

def create_document_summarizer():
    # Map-Reduce 방식의 요약 체인
    summarize_chain = load_summarize_chain(
        llm=llm,
        chain_type="map_reduce",
        verbose=True
    )
    
    return summarize_chain

# 사용 예시
summarizer = create_document_summarizer()
summary = summarizer.invoke({"input_documents": documents})

3. 코드 리뷰 어시스턴트

class CodeReviewAssistant:
    def __init__(self):
        self.llm = ChatOpenAI(temperature=0.2)
        
        self.review_prompt = ChatPromptTemplate.from_template("""
        다음 코드를 리뷰하고 개선 사항을 제안해주세요:
        
        언어: {language}
        코드:
        ```{language}
        {code}
        ```
        
        리뷰 결과:
        1. 코드 품질 평가
        2. 개선 사항
        3. 보안 이슈
        4. 성능 최적화 제안
        """)
        
        self.chain = self.review_prompt | self.llm | StrOutputParser()
    
    def review_code(self, code, language="python"):
        return self.chain.invoke({
            "code": code,
            "language": language
        })

🔥 LangChain의 고급 기능

1. 커스텀 체인 생성

from langchain.schema.runnable import RunnableLambda, RunnablePassthrough

def create_analysis_chain():
    # 데이터 전처리
    preprocess = RunnableLambda(lambda x: x.upper().strip())
    
    # 분석 프롬프트
    analysis_prompt = ChatPromptTemplate.from_template(
        "다음 텍스트를 분석하고 감정과 주요 키워드를 추출하세요: {text}"
    )
    
    # 후처리
    postprocess = RunnableLambda(lambda x: {
        "analysis": x,
        "timestamp": "2025-07-02"
    })
    
    # 체인 조합
    chain = (
        {"text": preprocess} 
        | analysis_prompt 
        | llm 
        | StrOutputParser() 
        | postprocess
    )
    
    return chain

2. 병렬 처리

from langchain.schema.runnable import RunnableParallel

# 병렬로 여러 작업 수행
parallel_chain = RunnableParallel({
    "summary": summarize_chain,
    "sentiment": sentiment_chain,
    "keywords": keyword_chain
})

result = parallel_chain.invoke({"input": text})

🛠️ 성능 최적화 팁

1. 캐싱 활용

from langchain.cache import InMemoryCache
from langchain.globals import set_llm_cache

# 메모리 캐시 설정
set_llm_cache(InMemoryCache())

# 동일한 입력에 대해 캐시된 결과 반환

2. 스트리밍 응답

# 스트리밍으로 실시간 응답 받기
for chunk in chain.stream({"topic": "인공지능"}):
    print(chunk, end="", flush=True)

3. 비동기 처리

import asyncio

async def async_chain_execution():
    result = await chain.ainvoke({"input": "비동기 처리 테스트"})
    return result

# 사용
result = asyncio.run(async_chain_execution())

🔍 디버깅 및 로깅

import langchain
from langchain.globals import set_debug

# 디버그 모드 활성화
set_debug(True)

# 상세한 로깅
langchain.debug = True

# 체인 실행 과정 추적
chain = prompt | llm | StrOutputParser()
result = chain.invoke({"topic": "LangChain"})

🌟 LangChain vs 다른 프레임워크

특징	LangChain	LlamaIndex	Haystack
용도	범용 LLM 앱	데이터 검색 중심	기업용 NLP
학습곡선	보통	쉬움	어려움
확장성	높음	보통	높음
커뮤니티	매우 활발	활발	보통

🚀 실제 프로덕션 사례

A2A 프로젝트에서의 LangChain 활용

# 실제 프로젝트 예시 - AI 에이전트 대화 시스템
class BuyerAgent:
    def __init__(self):
        self.llm = ChatOpenAI(temperature=0.7)
        self.memory = ConversationSummaryBufferMemory(llm=self.llm)
        
        self.prompt = ChatPromptTemplate.from_template("""
        당신은 {company_name}의 구매 담당자입니다.
        회사 정보: {company_summary}
        
        판매자의 질문에 현실적이고 구체적으로 답변하세요.
        
        대화 기록: {chat_history}
        판매자 질문: {seller_message}
        
        답변:""")
        
        self.chain = self.prompt | self.llm | StrOutputParser()
    
    async def respond(self, company_name, company_summary, seller_message):
        chat_history = self.memory.chat_memory.messages
        
        response = await self.chain.ainvoke({
            "company_name": company_name,
            "company_summary": company_summary,
            "chat_history": chat_history,
            "seller_message": seller_message
        })
        
        # 메모리 업데이트
        self.memory.chat_memory.add_user_message(seller_message)
        self.memory.chat_memory.add_ai_message(response)
        
        return response

🎯 베스트 프랙티스

1. 프롬프트 엔지니어링

# ❌ 좋지 않은 예
bad_prompt = "코드를 리뷰해줘"

# ✅ 좋은 예
good_prompt = """
당신은 시니어 개발자입니다. 다음 기준으로 코드를 리뷰해주세요:

1. 코드 품질 (가독성, 유지보수성)
2. 성능 최적화 가능성
3. 보안 취약점
4. 코딩 컨벤션 준수

코드:
{code}

각 항목별로 구체적인 피드백을 제공해주세요.
"""

2. 에러 핸들링

from langchain.schema import OutputParserException

try:
    result = chain.invoke(input_data)
except OutputParserException as e:
    print(f"파싱 오류: {e}")
    # 대체 로직 실행
except Exception as e:
    print(f"예상치 못한 오류: {e}")
    # 로깅 및 복구 처리

3. 토큰 사용량 최적화

from langchain.callbacks import get_openai_callback

with get_openai_callback() as cb:
    result = chain.invoke(input_data)
    print(f"토큰 사용량: {cb.total_tokens}")
    print(f"비용: ${cb.total_cost:.4f}")

🎉 마무리

LangChain은 AI 애플리케이션 개발의 패러다임을 바꾸고 있습니다. 복잡한 AI 워크플로우를 모듈화된 구성 요소로 나누어 개발할 수 있게 해주며, RAG, 에이전트, 메모리 시스템 등 다양한 고급 기능을 제공합니다.

🔮 다음 스텝

실습 프로젝트 시작: 간단한 챗봇부터 구현
RAG 시스템 구축: 나만의 문서 기반 QA 시스템
에이전트 개발: 도구를 사용하는 자율적 AI 에이전트
프로덕션 배포: 실제 서비스에 LangChain 적용

이 글이 도움이 되셨다면 👍 좋아요와 댓글로 소통해요!

본 글은 Claude Desktop + MCP 자동화 시스템으로 작성되었습니다 🤖

김민범

이전 포스트

🤖 Claude Desktop + MCP로 자동화된 개발 환경 구축하기

다음 포스트