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

LangChain Memory로 만드는 지속 대화형 AI 봇 완전 정복 가이드
기억하는 봇 vs 기억 못하는 봇 — 차이는 단 하나, Memory 설정! 🧠✨
안녕! 오늘은 진짜 실용적인 주제를 들고 왔어. 바로 LangChain의 Memory 기능을 활용해서 대화 맥락을 기억하는 챗봇을 만드는 방법이야. 🎉
혹시 이런 경험 있어? ChatGPT 같은 AI한테 "아까 내가 말한 거 기억해?" 했더니 "죄송합니다, 이전 대화 내용을 기억하지 못합니다"라고 답하는 거. 😅
맞아, 기본 LLM은 무상태(stateless)야. 매번 새로운 대화처럼 처음부터 시작하거든. 그런데 LangChain의 Memory를 쓰면? 이야기가 완전히 달라져! 봇이 이전 대화를 기억하고, 맥락에 맞는 자연스러운 응답을 할 수 있게 돼. 마치 진짜 친구처럼 말이야. 🤝
이 글에서는 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에 저장, 유사도 검색 | 매우 긴 대화, 의미 기반 검색 |
🚀 ConversationBufferMemory 실전 구현
가장 기본적이고 직관적인 ConversationBufferMemory부터 시작해보자. 이름처럼 모든 대화를 버퍼에 그대로 저장하는 방식이야. 짧은 대화에 최적이고, 이해하기도 쉬워서 입문용으로 딱이야! 💪
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가 자동으로 이전 대화를 프롬프트에 포함시켜줘. 그래서 봇이 "지민"이라는 이름과 "파이썬 개발자"라는 직업을 기억하는 거야! 🎉
# 현재 저장된 메모리 확인
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=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 쌍)의 메시지만 유지
📝 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 챗봇 개발에 관심이 많으시죠!"
✅ 장점: 긴 대화도 압축 저장, 토큰 효율 높음, 핵심 정보 보존
❌ 단점: 요약 과정에서 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 등 다양한 백엔드를 사용할 수 있어!
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) # "네, 지민님이라고 하셨잖아요!"
# 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: 유연한 스키마, 문서 기반 저장
🌐 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
서버 실행 후
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의
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)
- ✅ 스트리밍 지원 (실시간 응답 출력)
- ✅ 비동기(async) 지원
- ✅ 배치 처리 지원
- ✅ 더 유연한 체인 구성
- ✅ LangSmith 추적 통합 용이
⚙️ 실전 최적화 팁 & 트러블슈팅
실제로 서비스를 운영하다 보면 다양한 문제에 부딪히게 돼. 미리 알아두면 삽질을 줄일 수 있는 꿀팁들을 정리해봤어! 🍯
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 같은 저비용 모델 활용
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}
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)
기존 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
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.