콘텐츠 대표 이미지 - LangChain Memory로 만드는 지속 대화형 AI 봇 완전 정복 가이드
🤖 AI 자동화 / 에이전트

LangChain Memory로 만드는 지속 대화형 AI 봇 완전 정복 가이드

기억하는 봇 vs 기억 못하는 봇 — 차이는 단 하나, Memory 설정! 🧠✨

안녕! 오늘은 진짜 실용적인 주제를 들고 왔어. 바로 LangChain의 Memory 기능을 활용해서 대화 맥락을 기억하는 챗봇을 만드는 방법이야. 🎉

혹시 이런 경험 있어? ChatGPT 같은 AI한테 "아까 내가 말한 거 기억해?" 했더니 "죄송합니다, 이전 대화 내용을 기억하지 못합니다"라고 답하는 거. 😅

맞아, 기본 LLM은 무상태(stateless)야. 매번 새로운 대화처럼 처음부터 시작하거든. 그런데 LangChain의 Memory를 쓰면? 이야기가 완전히 달라져! 봇이 이전 대화를 기억하고, 맥락에 맞는 자연스러운 응답을 할 수 있게 돼. 마치 진짜 친구처럼 말이야. 🤝

이 글에서는 LangChain Memory의 개념부터 실제 코드 구현까지, 단계별로 쭉 파헤쳐볼 거야. 준비됐어? 고고! 🚀

LangChain Memory 동작 원리 👤 사용자 "안녕! 내 이름은 지민이야" ↓ 다음 대화 "내 이름이 뭐였지?" LangChain Chain / Agent 프롬프트 조합 + 메모리 주입 + LLM 호출 + 응답 반환 Memory 대화 히스토리 저장 ConversationBuffer Summary Memory Window Memory Vector Memory Entity Memory LLM GPT-4 / Claude 맥락 이해 후 자연스러운 응답 "지민님, 안녕하세요! 아까 말씀하셨죠 😊" 🔄 Memory가 대화 히스토리를 저장 → Chain이 프롬프트에 자동 주입 → LLM이 맥락 파악 → 자연스러운 응답! 이 흐름이 바로 LangChain Memory의 핵심이야 ✨

🧠 LangChain Memory가 뭔데? 기초부터 잡자!

LangChain은 LLM(대형 언어 모델)을 활용한 애플리케이션을 쉽게 만들 수 있게 해주는 파이썬/자바스크립트 프레임워크야. 그 안에서 Memory는 이름 그대로 "봇이 이전 대화를 기억하게 해주는 컴포넌트"야.

LLM 자체는 기본적으로 무상태(stateless)야. 즉, 매번 API를 호출할 때마다 완전히 새로운 요청으로 처리해. 이전에 뭘 얘기했는지 전혀 모르는 거지. 그래서 "아까 내가 뭐라고 했지?"라고 물으면 당연히 모른다고 해.

LangChain Memory는 이 문제를 해결하기 위해 대화 히스토리를 저장하고, 새로운 요청 시 프롬프트에 자동으로 포함시켜줘. 덕분에 LLM은 마치 이전 대화를 기억하는 것처럼 동작하게 되는 거야! 🎯

💡 핵심 개념 정리
Memory의 역할: 대화 히스토리를 저장하고, 새 요청 시 컨텍스트로 주입
저장 방식: 인메모리(RAM), 파일, DB, 벡터스토어 등 다양
주입 방식: 프롬프트 템플릿의 특정 변수에 자동 삽입
종류: Buffer, Summary, Window, Entity, Vector 등 상황에 맞게 선택

🔧 LangChain 설치부터 시작!

일단 환경 세팅부터 해보자. 파이썬 3.8 이상이면 OK야.

# 기본 LangChain 설치
pip install langchain langchain-openai langchain-community

# OpenAI 사용 시
pip install openai

# 환경변수 설정 (.env 파일 또는 직접 설정)
# OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxx
🌟 팁! python-dotenv 패키지를 함께 설치하면 .env 파일로 API 키를 안전하게 관리할 수 있어. pip install python-dotenv로 설치하고, 코드 상단에 from dotenv import load_dotenv; load_dotenv()를 추가해줘.

📦 Memory 종류 완전 해부!

LangChain에는 여러 종류의 Memory가 있어. 각각 특성이 다르니까 상황에 맞게 골라 써야 해. 하나씩 살펴보자! 👀

Memory 종류 특징 적합한 상황
ConversationBufferMemory 모든 대화를 그대로 저장 짧은 대화, 정확한 히스토리 필요
ConversationBufferWindowMemory 최근 N개 대화만 유지 토큰 절약, 최근 맥락만 필요
ConversationSummaryMemory 대화를 요약해서 저장 긴 대화, 토큰 효율 중요
ConversationSummaryBufferMemory 요약 + 최근 대화 혼합 균형잡힌 메모리 관리
ConversationEntityMemory 특정 엔티티(사람, 장소 등) 추적 특정 정보 집중 관리
VectorStoreRetrieverMemory 벡터 DB에 저장, 유사도 검색 매우 긴 대화, 의미 기반 검색
Memory 종류별 동작 방식 비교 Buffer Memory 전체 대화 저장 👤 "안녕, 나는 지민이야" 🤖 "안녕하세요 지민님!" 👤 "내 이름이 뭐야?" 🤖 "지민님이라고 하셨죠!" ✅ 전체 기억 유지 Window Memory (k=2) 최근 2개 대화만 유지 👤 "안녕" ← 삭제됨 🤖 "안녕하세요" ← 삭제됨 👤 "오늘 날씨 어때?" 🤖 "맑고 좋아요!" ⚡ 토큰 절약, 최근만 기억 Summary Memory 대화를 요약해서 저장 📝 요약본: "사용자는 지민이며 파이썬 개발자임. LangChain에 관심있음" ✅ 긴 대화도 압축 저장 Entity Memory 특정 엔티티(개체) 정보를 별도 추적 엔티티 저장소 지민: 파이썬 개발자 서울: 거주지 LangChain: 관심 기술 재능넷: 활동 플랫폼 활용 예시 "지민님은 서울에 사시는 파이썬 개발자 이시군요! LangChain 관심 있으시죠?" Vector Store Memory 의미 기반 유사도 검색으로 관련 대화 불러오기 🔍 "LangChain 설치 방법?" ↓ 벡터 유사도 검색 과거 대화 중 "LangChain", "설치", "pip install" 관련 내용 자동 검색 ✅ 수천 개 대화에서도 관련 맥락 정확히 추출! 상황에 맞는 Memory를 선택하는 것이 핵심! 🎯

🚀 ConversationBufferMemory 실전 구현

가장 기본적이고 직관적인 ConversationBufferMemory부터 시작해보자. 이름처럼 모든 대화를 버퍼에 그대로 저장하는 방식이야. 짧은 대화에 최적이고, 이해하기도 쉬워서 입문용으로 딱이야! 💪

1 기본 ConversationChain 만들기
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI

# LLM 초기화
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0.7,
    openai_api_key="your-api-key"
)

# Memory 초기화
memory = ConversationBufferMemory(
    return_messages=True  # 메시지 객체 형태로 반환
)

# ConversationChain 생성
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True  # 디버그 출력 활성화
)

# 대화 시작!
response1 = conversation.predict(input="안녕! 나는 지민이야. 파이썬 개발자야.")
print(response1)
# 출력: "안녕하세요 지민님! 파이썬 개발자시군요, 반갑습니다!"

response2 = conversation.predict(input="내 이름이 뭐야?")
print(response2)
# 출력: "지민님이라고 하셨잖아요! 😊"

response3 = conversation.predict(input="내 직업은?")
print(response3)
# 출력: "파이썬 개발자라고 하셨어요!"

보이지? conversation.predict()를 호출할 때마다 Memory가 자동으로 이전 대화를 프롬프트에 포함시켜줘. 그래서 봇이 "지민"이라는 이름과 "파이썬 개발자"라는 직업을 기억하는 거야! 🎉

2 Memory 내용 직접 확인하기
# 현재 저장된 메모리 확인
print(memory.chat_memory.messages)
# [HumanMessage(content='안녕! 나는 지민이야...'),
#  AIMessage(content='안녕하세요 지민님!...'),
#  HumanMessage(content='내 이름이 뭐야?'),
#  AIMessage(content='지민님이라고 하셨잖아요!'),
#  ...]

# 버퍼 형태로 확인
print(memory.buffer)
# Human: 안녕! 나는 지민이야...
# AI: 안녕하세요 지민님!...

# 메모리 초기화 (대화 리셋)
memory.clear()
print(memory.chat_memory.messages)  # []
🌟 return_messages 옵션 차이! return_messages=True: HumanMessage, AIMessage 객체 형태로 반환 → ChatModel에 적합
return_messages=False: 문자열 형태로 반환 → 일반 LLM에 적합
ChatOpenAI 같은 Chat 모델 쓸 때는 True로 설정하는 게 좋아!

🪟 ConversationBufferWindowMemory — 토큰 절약의 달인

대화가 길어지면 Buffer Memory는 토큰을 엄청 많이 먹어. OpenAI API는 토큰당 과금이니까 비용이 폭발할 수 있어 💸

이럴 때 WindowMemory가 구원투수야! 최근 k개의 대화만 유지하고 나머지는 버려버려. 최신 맥락만 중요한 경우에 딱이야.

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

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

# k=3: 최근 3번의 대화 교환만 기억
memory = ConversationBufferWindowMemory(
    k=3,
    return_messages=True
)

conversation = ConversationChain(llm=llm, memory=memory)

# 여러 번 대화
conversation.predict(input="1번 대화: 나는 지민이야")
conversation.predict(input="2번 대화: 나는 서울에 살아")
conversation.predict(input="3번 대화: 나는 파이썬 좋아해")
conversation.predict(input="4번 대화: 오늘 날씨 좋다")

# 이 시점에서 1번 대화는 이미 삭제됨!
response = conversation.predict(input="내 이름이 뭐야?")
# 봇: "죄송해요, 이름을 말씀해주신 내용이 현재 기억에 없어요..."
# (k=3이라 1번 대화가 밀려났기 때문)

# 메모리 상태 확인
print(f"현재 저장된 대화 수: {len(memory.chat_memory.messages)}")
# 최대 k*2개 (human + ai 쌍)의 메시지만 유지
⚠️ 주의! WindowMemory에서 k값은 "대화 교환 횟수"야. k=3이면 Human-AI 쌍이 3개, 즉 총 6개의 메시지가 저장돼. 너무 작게 설정하면 중요한 맥락이 날아갈 수 있으니 적절히 조절해줘!

📝 ConversationSummaryMemory — 요약의 마법사

긴 대화를 그대로 저장하면 토큰이 너무 많이 들어. 그렇다고 Window처럼 잘라버리면 중요한 정보가 사라질 수 있어.

SummaryMemory는 이 딜레마를 해결해줘! LLM을 이용해서 대화 내용을 자동으로 요약하고, 그 요약본을 메모리로 유지해. 핵심 정보는 보존하면서 토큰은 절약하는 스마트한 방식이야! 🧙‍♂️

from langchain.memory import ConversationSummaryMemory
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI

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

# SummaryMemory는 요약을 위해 LLM도 필요해
memory = ConversationSummaryMemory(
    llm=llm,
    return_messages=True
)

conversation = ConversationChain(llm=llm, memory=memory)

# 긴 대화 진행
conversation.predict(input="안녕! 나는 지민이야. 서울 강남구에 살고 있어.")
conversation.predict(input="나는 5년차 파이썬 개발자야. 주로 AI/ML 프로젝트를 해.")
conversation.predict(input="요즘 LangChain 공부 중이야. 챗봇 만들고 싶어서.")
conversation.predict(input="재능넷에서 AI 관련 재능을 판매해볼까 생각 중이야.")

# 현재 요약 확인
print(memory.moving_summary_buffer)
# "사용자 지민은 서울 강남구 거주 5년차 파이썬/AI 개발자로,
#  LangChain을 공부하며 챗봇 개발을 목표로 하고 있음.
#  재능넷에서 AI 재능 판매도 고려 중."

# 요약된 내용으로 자연스러운 대화 가능
response = conversation.predict(input="내가 어떤 사람이야?")
print(response)
# "지민님은 서울 강남구에 사시는 5년차 파이썬 개발자이시고,
#  AI/ML 전문가로 LangChain 챗봇 개발에 관심이 많으시죠!"
💡 SummaryMemory의 장단점
✅ 장점: 긴 대화도 압축 저장, 토큰 효율 높음, 핵심 정보 보존
❌ 단점: 요약 과정에서 LLM 추가 호출 발생(비용↑), 세부 내용 손실 가능

⚡ ConversationSummaryBufferMemory — 하이브리드 최강자

Summary와 Buffer의 장점만 쏙 뽑은 하이브리드 메모리야! 토큰 한도를 설정하면, 그 한도 내에서는 대화를 그대로 유지하고, 한도를 초과하면 오래된 대화를 요약해서 저장해. 실제 프로덕션 환경에서 가장 많이 쓰이는 방식이야! 🏆

from langchain.memory import ConversationSummaryBufferMemory
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI

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

# max_token_limit: 이 토큰 수를 초과하면 오래된 대화를 요약
memory = ConversationSummaryBufferMemory(
    llm=llm,
    max_token_limit=500,  # 500 토큰 초과 시 요약 시작
    return_messages=True
)

conversation = ConversationChain(llm=llm, memory=memory)

# 대화 진행
for i in range(10):
    response = conversation.predict(
        input=f"이것은 {i+1}번째 대화야. 내용은 파이썬 개발 관련이야."
    )

# 500 토큰 초과 후 자동으로 오래된 대화 요약
# 최근 대화는 그대로 유지, 오래된 건 요약본으로 압축
print(memory.moving_summary_buffer)  # 요약된 오래된 대화
print(len(memory.chat_memory.messages))  # 최근 대화 메시지 수

🏷️ ConversationEntityMemory — 인물 정보 전문가

특정 엔티티(사람, 장소, 사물 등)에 대한 정보를 별도로 추적하고 싶을 때 쓰는 메모리야. 예를 들어 CRM 봇이나 개인화 서비스에서 사용자 정보를 체계적으로 관리할 때 유용해! 🎯

from langchain.memory import ConversationEntityMemory
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI

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

memory = ConversationEntityMemory(
    llm=llm,
    return_messages=True
)

conversation = ConversationChain(llm=llm, memory=memory)

# 여러 엔티티 정보 입력
conversation.predict(input="지민은 서울에 사는 파이썬 개발자야.")
conversation.predict(input="수진은 지민의 친구인데 디자이너야.")
conversation.predict(input="지민은 요즘 LangChain 프로젝트를 하고 있어.")

# 엔티티 저장소 확인
print(memory.entity_store.store)
# {
#   '지민': '서울 거주 파이썬 개발자, LangChain 프로젝트 진행 중',
#   '수진': '지민의 친구, 디자이너'
# }

# 특정 엔티티 정보 조회
response = conversation.predict(input="수진에 대해 알려줘")
print(response)
# "수진은 지민님의 친구이고 디자이너라고 하셨어요!"

🗄️ 대화 기록을 DB에 영구 저장하기

지금까지 본 Memory들은 모두 인메모리(RAM) 방식이야. 프로그램을 종료하면 대화 내용이 사라져버려. 실제 서비스에서는 대화를 영구적으로 저장해야 하잖아? 🤔

LangChain은 다양한 영구 저장소를 지원해. Redis, SQLite, PostgreSQL, MongoDB 등 다양한 백엔드를 사용할 수 있어!

1 SQLite로 대화 영구 저장
from langchain_community.chat_message_histories import SQLChatMessageHistory
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI

# SQLite DB에 대화 저장
# session_id로 사용자별 대화 분리 가능!
chat_history = SQLChatMessageHistory(
    session_id="user_jimin_001",  # 사용자 고유 ID
    connection_string="sqlite:///chat_history.db"
)

memory = ConversationBufferMemory(
    chat_memory=chat_history,
    return_messages=True
)

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)
conversation = ConversationChain(llm=llm, memory=memory)

# 대화 (DB에 자동 저장됨)
response = conversation.predict(input="안녕! 나는 지민이야.")
print(response)

# 프로그램 재시작 후에도 이전 대화 기억!
# session_id가 같으면 DB에서 히스토리 자동 로드
chat_history2 = SQLChatMessageHistory(
    session_id="user_jimin_001",
    connection_string="sqlite:///chat_history.db"
)
memory2 = ConversationBufferMemory(
    chat_memory=chat_history2,
    return_messages=True
)
conversation2 = ConversationChain(llm=llm, memory=memory2)

# 이전 대화 기억하고 있음!
response2 = conversation2.predict(input="내 이름 기억해?")
print(response2)  # "네, 지민님이라고 하셨잖아요!"
2 Redis로 대화 저장 (고성능 서비스용)
# Redis 설치 필요: pip install redis langchain-community
from langchain_community.chat_message_histories import RedisChatMessageHistory
from langchain.memory import ConversationBufferMemory

# Redis 연결
chat_history = RedisChatMessageHistory(
    session_id="user_jimin_001",
    url="redis://localhost:6379/0",
    ttl=86400  # 24시간 후 자동 만료 (선택사항)
)

memory = ConversationBufferMemory(
    chat_memory=chat_history,
    return_messages=True
)

# 이후 사용법은 동일!
🌟 어떤 저장소를 선택할까?
📁 SQLite: 개발/테스트, 소규모 서비스, 파일 기반
🔴 Redis: 고성능, 실시간 서비스, TTL 지원
🐘 PostgreSQL: 대규모 서비스, 복잡한 쿼리 필요 시
🍃 MongoDB: 유연한 스키마, 문서 기반 저장
지속 대화형 봇 아키텍처 전체 구조 👤 사용자 🌐 API 서버 FastAPI/Flask ⛓️ LangChain Chain + Memory 🤖 LLM GPT-4 / Claude 💬 응답 사용자에게 ↕ Memory 저장소 (영구 보존) 📁 SQLite 개발/소규모 🔴 Redis 고성능/실시간 🐘 PostgreSQL 대규모 서비스 🍃 MongoDB 유연한 스키마 🔮 Vector DB 의미 검색 🔑 세션 관리 (session_id 기반 사용자별 대화 분리) user_001: "안녕 나는 지민" → user_002: "나는 수진" → 각자 독립된 메모리 유지 session_id = user_id + conversation_id 조합으로 다중 대화 지원 가능 🚀 이 구조로 실제 서비스 가능한 지속 대화형 봇 완성!

🌐 FastAPI로 실제 챗봇 서버 만들기

이론은 충분히 배웠으니 이제 진짜 서비스로 만들어보자! FastAPI와 LangChain Memory를 결합해서 실제로 동작하는 챗봇 API 서버를 만들어볼게. 이걸 기반으로 웹/앱 서비스를 붙이면 바로 서비스 가능해! 🔥

# pip install fastapi uvicorn langchain langchain-openai langchain-community

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from langchain.memory import ConversationSummaryBufferMemory
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI
from langchain_community.chat_message_histories import SQLChatMessageHistory
from typing import Dict
import os

app = FastAPI(title="LangChain 지속 대화형 봇 API")

# LLM 초기화
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0.7,
    openai_api_key=os.getenv("OPENAI_API_KEY")
)

# 요청/응답 모델
class ChatRequest(BaseModel):
    session_id: str  # 사용자 고유 ID
    message: str     # 사용자 메시지

class ChatResponse(BaseModel):
    session_id: str
    response: str
    message_count: int

# 세션별 conversation 캐시 (메모리 최적화)
conversation_cache: Dict[str, ConversationChain] = {}

def get_conversation(session_id: str) -> ConversationChain:
    """세션 ID로 대화 체인 가져오기 (없으면 새로 생성)"""
    if session_id not in conversation_cache:
        # SQLite에서 히스토리 로드
        chat_history = SQLChatMessageHistory(
            session_id=session_id,
            connection_string="sqlite:///chat_history.db"
        )
        
        memory = ConversationSummaryBufferMemory(
            llm=llm,
            chat_memory=chat_history,
            max_token_limit=1000,
            return_messages=True
        )
        
        conversation_cache[session_id] = ConversationChain(
            llm=llm,
            memory=memory,
            verbose=False
        )
    
    return conversation_cache[session_id]

@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    """대화 엔드포인트"""
    try:
        conversation = get_conversation(request.session_id)
        response = conversation.predict(input=request.message)
        
        # 메시지 수 계산
        msg_count = len(
            conversation.memory.chat_memory.messages
        )
        
        return ChatResponse(
            session_id=request.session_id,
            response=response,
            message_count=msg_count
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.delete("/chat/{session_id}")
async def clear_history(session_id: str):
    """대화 기록 초기화"""
    if session_id in conversation_cache:
        conversation_cache[session_id].memory.clear()
        del conversation_cache[session_id]
    return {"message": f"세션 {session_id} 초기화 완료"}

@app.get("/chat/{session_id}/history")
async def get_history(session_id: str):
    """대화 기록 조회"""
    conversation = get_conversation(session_id)
    messages = conversation.memory.chat_memory.messages
    return {
        "session_id": session_id,
        "messages": [
            {"role": "human" if i % 2 == 0 else "ai", 
             "content": msg.content}
            for i, msg in enumerate(messages)
        ]
    }

# 실행: uvicorn main:app --reload --port 8000
🌟 API 테스트 방법

서버 실행 후 http://localhost:8000/docs에 접속하면 FastAPI가 자동으로 Swagger UI를 제공해줘. 거기서 바로 API 테스트 가능! 또는 curl로도 테스트할 수 있어:

curl -X POST "http://localhost:8000/chat" -H "Content-Type: application/json" -d '{"session_id":"user001","message":"안녕!"}'

🎨 커스텀 프롬프트로 봇 개성 만들기

기본 ConversationChain도 좋지만, 커스텀 프롬프트 템플릿을 사용하면 봇에 특별한 개성을 부여할 수 있어. 친절한 고객 서비스 봇, 전문 기술 어시스턴트, 재미있는 캐릭터 봇 등 뭐든 만들 수 있어! 🎭

from langchain.prompts import (
    ChatPromptTemplate,
    MessagesPlaceholder,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate
)
from langchain.memory import ConversationBufferMemory
from langchain.chains import LLMChain
from langchain_openai import ChatOpenAI

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

# 커스텀 시스템 프롬프트 설정
prompt = ChatPromptTemplate.from_messages([
    SystemMessagePromptTemplate.from_template(
        """당신은 '코딩 멘토 AI'입니다.
        
        특징:
        - 친근하고 유머러스한 말투 사용
        - 복잡한 개념을 쉽고 재미있게 설명
        - 사용자의 이름을 기억하고 자주 불러줌
        - 코드 예시를 적극 활용
        - 격려와 칭찬을 아끼지 않음
        
        현재까지의 대화 기록:
        {chat_history}
        """
    ),
    HumanMessagePromptTemplate.from_template("{input}")
])

# MessagesPlaceholder를 사용한 방식 (더 권장됨)
prompt_v2 = ChatPromptTemplate.from_messages([
    ("system", """당신은 친근한 AI 코딩 멘토입니다.
    항상 격려하고, 쉽게 설명하며, 사용자를 이름으로 불러주세요."""),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}")
])

memory = ConversationBufferMemory(
    memory_key="chat_history",  # 프롬프트의 변수명과 일치!
    return_messages=True
)

chain = LLMChain(
    llm=llm,
    prompt=prompt_v2,
    memory=memory,
    verbose=True
)

# 대화 테스트
response1 = chain.predict(input="안녕! 나는 지민이야. 파이썬 초보야.")
print(response1)
# "안녕하세요 지민님! 파이썬 세계에 오신 걸 환영해요! 🎉
#  초보라고 하셨지만, 시작이 반이에요! 무엇부터 배워볼까요?"

response2 = chain.predict(input="리스트 컴프리헨션이 뭐야?")
print(response2)
# "지민님, 좋은 질문이에요! 리스트 컴프리헨션은..."
💡 memory_key 주의사항!

Memory의 memory_key는 프롬프트 템플릿의 변수명과 반드시 일치해야 해!
기본값은 "history"인데, 커스텀 프롬프트에서 {chat_history}를 쓴다면
ConversationBufferMemory(memory_key="chat_history")
로 설정해야 해.

🔗 LCEL(LangChain Expression Language)로 최신 방식 구현

LangChain v0.1 이후부터는 LCEL(LangChain Expression Language)이 권장 방식이야. 파이프(|) 연산자로 체인을 구성하는 더 직관적이고 유연한 방식이야. 최신 LangChain을 쓴다면 이 방식을 익혀두는 게 좋아! 🆕

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import SQLChatMessageHistory
from langchain_openai import ChatOpenAI

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

# 프롬프트 템플릿
prompt = ChatPromptTemplate.from_messages([
    ("system", "당신은 친절한 AI 어시스턴트입니다."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

# LCEL 체인 구성 (파이프 연산자 사용)
chain = prompt | llm

# RunnableWithMessageHistory로 메모리 연결
def get_session_history(session_id: str):
    return SQLChatMessageHistory(
        session_id=session_id,
        connection_string="sqlite:///chat_history.db"
    )

# 메모리가 연결된 최종 체인
chain_with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history"
)

# 대화 실행
config = {"configurable": {"session_id": "user_jimin_001"}}

response1 = chain_with_history.invoke(
    {"input": "안녕! 나는 지민이야."},
    config=config
)
print(response1.content)

response2 = chain_with_history.invoke(
    {"input": "내 이름 기억해?"},
    config=config
)
print(response2.content)
# "네, 지민님이라고 하셨잖아요! 😊"

# 스트리밍 응답도 지원!
for chunk in chain_with_history.stream(
    {"input": "파이썬에 대해 설명해줘"},
    config=config
):
    print(chunk.content, end="", flush=True)
🌟 LCEL의 장점!
  • ✅ 스트리밍 지원 (실시간 응답 출력)
  • ✅ 비동기(async) 지원
  • ✅ 배치 처리 지원
  • ✅ 더 유연한 체인 구성
  • ✅ LangSmith 추적 통합 용이

⚙️ 실전 최적화 팁 & 트러블슈팅

실제로 서비스를 운영하다 보면 다양한 문제에 부딪히게 돼. 미리 알아두면 삽질을 줄일 수 있는 꿀팁들을 정리해봤어! 🍯

1 토큰 비용 최적화
from langchain.callbacks import get_openai_callback

# 토큰 사용량 추적
with get_openai_callback() as cb:
    response = conversation.predict(input="안녕!")
    print(f"사용 토큰: {cb.total_tokens}")
    print(f"비용: ${cb.total_cost:.6f}")

# 토큰 최적화 전략
# 1. SummaryBufferMemory 사용 (max_token_limit 적절히 설정)
# 2. 시스템 프롬프트 간결하게 작성
# 3. 불필요한 대화 히스토리 주기적 정리
# 4. gpt-4o-mini 같은 저비용 모델 활용
2 동시 사용자 처리 (비동기)
import asyncio
from langchain_openai import ChatOpenAI

# 비동기 LLM 초기화
llm = ChatOpenAI(model="gpt-4o-mini")

# 비동기 대화 처리
async def async_chat(session_id: str, message: str):
    conversation = get_conversation(session_id)
    # apredict: 비동기 버전
    response = await conversation.apredict(input=message)
    return response

# FastAPI에서 async 엔드포인트 사용
@app.post("/chat/async")
async def async_chat_endpoint(request: ChatRequest):
    response = await async_chat(
        request.session_id, 
        request.message
    )
    return {"response": response}
3 메모리 누수 방지
import time
from collections import OrderedDict

# LRU 캐시로 메모리 관리
class LRUConversationCache:
    def __init__(self, max_size=100):
        self.cache = OrderedDict()
        self.max_size = max_size
        self.last_access = {}
    
    def get(self, session_id):
        if session_id in self.cache:
            # 최근 접근 시간 업데이트
            self.cache.move_to_end(session_id)
            self.last_access[session_id] = time.time()
            return self.cache[session_id]
        return None
    
    def set(self, session_id, conversation):
        if session_id in self.cache:
            self.cache.move_to_end(session_id)
        else:
            if len(self.cache) >= self.max_size:
                # 가장 오래된 항목 제거
                oldest = next(iter(self.cache))
                del self.cache[oldest]
                del self.last_access[oldest]
        self.cache[session_id] = conversation
        self.last_access[session_id] = time.time()

# 전역 캐시 사용
cache = LRUConversationCache(max_size=200)
⚠️ 흔한 실수들!
  • ❌ memory_key 불일치: 프롬프트 변수명과 memory_key가 다르면 메모리가 주입 안 됨
  • ❌ return_messages 설정 오류: ChatModel엔 True, 일반 LLM엔 False
  • ❌ 세션 관리 미흡: 모든 사용자가 같은 메모리 공유하는 버그
  • ❌ 무한 메모리 증가: Buffer Memory만 쓰면 토큰 폭발 위험
  • ❌ 동기/비동기 혼용: async 환경에서 동기 함수 호출 시 블로킹 발생

🎯 실전 프로젝트: 개인화 학습 도우미 봇

지금까지 배운 내용을 종합해서 실제로 쓸 수 있는 개인화 학습 도우미 봇을 만들어보자! 사용자의 학습 수준, 관심사, 진도를 기억하고 맞춤형 학습을 제공하는 봇이야. 재능넷 같은 플랫폼에서 AI 튜터링 서비스로 활용할 수 있는 형태야! 🎓

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import SQLChatMessageHistory
from langchain_openai import ChatOpenAI
from pydantic import BaseModel
import json

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

# 학습 도우미 전용 프롬프트
TUTOR_SYSTEM_PROMPT = """당신은 개인화된 AI 학습 도우미입니다.

핵심 역할:
1. 사용자의 학습 수준을 파악하고 기억
2. 이전 학습 내용을 바탕으로 연계 학습 제공
3. 사용자가 어려워하는 부분을 기억하고 반복 설명
4. 학습 진도와 성취를 추적하고 격려

대화 스타일:
- 친근하고 격려하는 톤
- 개념 설명 시 실생활 예시 활용
- 이해도 확인 질문 적극 활용
- 사용자 이름을 기억하고 자주 호칭

중요: 사용자가 이전에 배운 내용을 언급하며 연결고리를 만들어주세요."""

prompt = ChatPromptTemplate.from_messages([
    ("system", TUTOR_SYSTEM_PROMPT),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

chain = prompt | llm

def get_session_history(session_id: str):
    return SQLChatMessageHistory(
        session_id=session_id,
        connection_string="sqlite:///tutor_history.db"
    )

tutor_chain = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history"
)

class TutorSession:
    def __init__(self, user_id: str, subject: str):
        self.session_id = f"{user_id}_{subject}"
        self.config = {"configurable": {"session_id": self.session_id}}
    
    def chat(self, message: str) -> str:
        response = tutor_chain.invoke(
            {"input": message},
            config=self.config
        )
        return response.content
    
    def get_history_summary(self) -> str:
        """학습 히스토리 요약 요청"""
        return self.chat(
            "지금까지 우리가 공부한 내용을 간단히 요약해줘. "
            "내가 잘 이해한 부분과 더 연습이 필요한 부분도 알려줘."
        )

# 사용 예시
session = TutorSession(user_id="jimin_001", subject="python")

# 첫 번째 세션
print(session.chat("안녕! 나는 지민이야. 파이썬 기초부터 배우고 싶어."))
print(session.chat("변수가 뭐야?"))
print(session.chat("리스트는?"))

# 나중에 다시 접속해도 이전 학습 내용 기억!
# (SQLite에 저장되어 있으므로)
print(session.chat("저번에 배운 변수 개념 다시 설명해줄 수 있어?"))
print(session.get_history_summary())

📊 Memory 선택 가이드 — 어떤 걸 써야 할까?

상황에 따라 어떤 Memory를 선택해야 할지 헷갈릴 수 있어. 이 가이드를 참고해서 최적의 선택을 해봐! 🗺️

상황 추천 Memory 이유
짧은 대화 (10턴 이하) BufferMemory 간단하고 정확, 토큰 걱정 없음
토큰 비용 절약 필요 WindowMemory (k=5~10) 최근 대화만 유지, 비용 절감
긴 대화, 핵심 정보 보존 SummaryBufferMemory 요약+최근 대화 하이브리드
특정 인물/사물 정보 추적 EntityMemory 엔티티별 정보 체계적 관리
수천 개 대화 기록 검색 VectorStoreMemory 의미 기반 유사도 검색
프로덕션 서비스 (일반) SummaryBufferMemory + SQLite/Redis 균형잡힌 성능 + 영구 저장
고성능 실시간 서비스 WindowMemory + Redis 빠른 응답 + 확장성
🎯 실무 추천 조합
스타트업/소규모: ConversationSummaryBufferMemory + SQLite
중규모 서비스: ConversationSummaryBufferMemory + PostgreSQL + Redis 캐시
대규모 서비스: VectorStoreRetrieverMemory + Pinecone/Weaviate + Redis

재능넷처럼 다양한 사용자가 활동하는 플랫폼이라면 세션 관리와 영구 저장이 핵심이야!

🔮 LangGraph로 더 강력한 메모리 관리

LangChain의 최신 트렌드는 LangGraph야! 기존 Chain 방식보다 훨씬 유연하고 강력한 상태 관리가 가능해. 특히 복잡한 대화 흐름이나 멀티 에이전트 시스템에서 빛을 발해. 간단히 맛보기만 해볼게! 🌟

# pip install langgraph
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.sqlite import SqliteSaver
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage
from typing import TypedDict, Annotated, Sequence
import operator

# 상태 정의
class ConversationState(TypedDict):
    messages: Annotated[Sequence, operator.add]
    user_name: str
    topic: str

llm = ChatOpenAI(model="gpt-4o-mini")

# 노드 함수 정의
def chat_node(state: ConversationState):
    messages = state["messages"]
    response = llm.invoke(messages)
    return {"messages": [response]}

# 그래프 구성
workflow = StateGraph(ConversationState)
workflow.add_node("chat", chat_node)
workflow.set_entry_point("chat")
workflow.add_edge("chat", END)

# SQLite 체크포인터로 상태 영구 저장
memory = SqliteSaver.from_conn_string("chat_states.db")
app = workflow.compile(checkpointer=memory)

# 대화 실행
config = {"configurable": {"thread_id": "user_jimin_001"}}

result = app.invoke(
    {
        "messages": [HumanMessage(content="안녕! 나는 지민이야.")],
        "user_name": "지민",
        "topic": "파이썬"
    },
    config=config
)

print(result["messages"][-1].content)

# 같은 thread_id로 다시 호출하면 이전 상태 자동 복원!
result2 = app.invoke(
    {"messages": [HumanMessage(content="내 이름 기억해?")]},
    config=config
)
print(result2["messages"][-1].content)
🌟 LangGraph vs 기존 Chain
기존 Chain: 선형적 흐름, 단순한 대화에 적합
LangGraph: 그래프 기반 흐름, 조건 분기/루프/병렬 처리 가능

복잡한 에이전트 시스템이나 멀티스텝 워크플로우라면 LangGraph가 훨씬 강력해!

🎉 마무리 — 지속 대화형 봇의 무한한 가능성

와, 정말 많은 내용을 다뤘어! 🎊 LangChain Memory의 기초부터 실전 구현, 최적화까지 쭉 달려왔는데 어때? 생각보다 어렵지 않지?

핵심을 정리하면:

🔑 핵심 요약
1️⃣ LLM은 기본적으로 무상태 → Memory로 대화 맥락 주입
2️⃣ Memory 종류 선택이 핵심 → 상황에 맞게 Buffer/Window/Summary/Entity/Vector
3️⃣ 영구 저장은 필수 → SQLite/Redis/PostgreSQL로 세션 관리
4️⃣ 커스텀 프롬프트로 봇 개성 부여
5️⃣ LCEL + RunnableWithMessageHistory가 최신 권장 방식
6️⃣ 토큰 비용 관리는 실서비스에서 매우 중요
7️⃣ LangGraph로 더 복잡한 대화 흐름 구현 가능

이 기술을 활용하면 고객 서비스 봇, 개인화 학습 도우미, AI 비서, 게임 NPC 등 정말 다양한 서비스를 만들 수 있어. 특히 재능넷 같은 플랫폼에서 AI 기반 서비스를 제공하고 싶다면 LangChain Memory는 필수 기술이야! 🚀

처음엔 ConversationBufferMemory로 시작해서 점점 복잡한 Memory 타입으로 발전시켜 나가는 걸 추천해. 완벽한 봇은 한 번에 만들어지지 않아 — 계속 개선하고 실험하다 보면 어느새 멋진 AI 봇이 완성되어 있을 거야! 💪

자, 이제 직접 만들어볼 차례야. 코드 에디터 열고 고고! 🎯

댓글 작성

이 글에 대한 여러분의 생각을 들려주세요

댓글 0
댓글을 불러오는 중입니다.

아직 댓글이 없습니다.