LLM Apps in Production (RAG + Vector DB + Caching) · 강의

세션 관리와 컨텍스트 지속성

매끄러운 LLM 경험을 위해 여러 상호 작용에 걸쳐 대화 상태와 사용자 컨텍스트를 유지하는 방법을 배웁니다.

세션 관리와 컨텍스트 지속성은(는) CoddyKit의 무료 LLM Apps in Production (RAG + Vector DB + Caching) 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 LLM Apps in Production (RAG + Vector DB + Caching) 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. LLM Apps in Production (RAG + Vector DB + Caching) 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Why LLMs Need Memory

Imagine talking to someone who forgets everything you said a moment ago. That's often how Large Language Models (LLMs) work by default!

For a truly natural and helpful experience, LLM applications need to remember past interactions. This is where session management and context persistence come in.

LLMs: Stateless by Design

When you send a prompt to an LLM API, it processes that single request independently. It doesn't inherently 'remember' any previous prompts or responses.

Each API call is a fresh start.
This stateless nature is efficient for simple, one-off questions.
But it breaks down for conversations or personalized tasks.

Keeping the Conversation Flow

Context persistence is the technique of storing and retrieving relevant past information to include with new LLM requests.

This allows the LLM to understand the ongoing conversation, user preferences, or specific details provided earlier, making its responses much more coherent and useful.

Basic Strategy: Conversation History

The most common way to persist context for chat-based LLM applications is to maintain a conversation history.

Each user query and LLM response is added to a list.
Before sending a new user query, this entire history is included in the prompt.
This gives the LLM the full 'memory' of the interaction.

Simulating Chat History

Let's see a simple Python example where we build up a conversation history in a list. Notice how new messages are appended.

def simulate_chat():
  chat_history = []

  chat_history.append({"role": "user", "content": "Hi there!"})
  chat_history.append({"role": "assistant", "content": "Hello! How can I help?"})
  chat_history.append({"role": "user", "content": "What's the weather?"})

  print("--- Current Chat History ---")
  for msg in chat_history:
    print(f"{msg['role']}: {msg['content']}")

if __name__ == "__main__":
  simulate_chat()

Limitations of In-Memory History

While simple Python lists are great for demonstration, they have big limitations for real-world apps:

Ephemeral: Data is lost if the application restarts.
Single Session: Only works for one user's current interaction.
Scaling Issues: Not suitable for multiple concurrent users.

We need more robust solutions for persistence!

Storing Context Externally

To overcome in-memory limitations, context must be stored in an external, persistent system.

Common choices include:

Databases: SQL (PostgreSQL, MySQL) or NoSQL (MongoDB, Cassandra) for structured history.
Key-Value Stores: Redis or Memcached for fast access to session data.
Cloud Storage: Object storage like S3 for less frequent access.

Context in Action: LLM Call

When using external storage, the process looks like this:

User sends a new message.
Application retrieves the user's past conversation context from the external store.
The full context (history + new message) is sent to the LLM.
LLM generates a response.
The new response is added to the context and saved back to the external store.

Conceptual Code: Using Stored Context

This conceptual snippet shows how you'd load history and combine it with a new message before sending to an LLM. Assume load_history() and save_history() interact with an external store.

def send_to_llm_with_context(user_id, new_message):
  # Imagine these load/save from Redis/DB
  def load_history(uid): return [] # Placeholder
  def save_history(uid, hist): pass # Placeholder

  history = load_history(user_id)
  history.append({"role": "user", "content": new_message})

  # Construct the full prompt for the LLM
  llm_prompt = "".join([f"{msg['role']}: {msg['content']}\n" for msg in history])
  llm_prompt += "Assistant: "

  print(f"--- Sending to LLM ---\n{llm_prompt}")

  # Simulate LLM response
  llm_response = "I understand." 
  history.append({"role": "assistant", "content": llm_response})
  save_history(user_id, history)

if __name__ == "__main__":
  send_to_llm_with_context("user_123", "Tell me about context persistence.")

More Than Just Chat History

Context persistence isn't limited to just conversation history. It can also include:

User Profiles: Name, preferences, location.
Application State: Current task, active selections.
Document References: Which documents a user has interacted with.

This enriches the LLM's understanding and allows for truly personalized experiences.

Check Your Understanding

Understanding why LLMs need context is crucial for building robust applications.

Recap: Remembering the Past

In this lesson, we explored the critical role of session management and context persistence for LLM applications.

LLMs are stateless, requiring explicit context.
Conversation history is a primary form of context.
External storage (databases, Redis) is vital for robust persistence.
Context goes beyond chat, including user profiles and app state.

Mastering context persistence is key to creating intuitive and powerful LLM experiences!

자주 묻는 질문

“세션 관리와 컨텍스트 지속성” 강의는 무료인가요?

네 — “세션 관리와 컨텍스트 지속성” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 LLM Apps in Production (RAG + Vector DB + Caching) 강의 전체를 잠금 해제할 수 있습니다. LLM Apps in Production (RAG + Vector DB + Caching) 강의에는 총 4개의 강의가 포함되어 있습니다.

“세션 관리와 컨텍스트 지속성”에서 뭘 배우나요?

매끄러운 LLM 경험을 위해 여러 상호 작용에 걸쳐 대화 상태와 사용자 컨텍스트를 유지하는 방법을 배웁니다. 브라우저에서 직접 실행하는 실습 코드로 LLM Apps in Production (RAG + Vector DB + Caching)을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

LLM Apps in Production (RAG + Vector DB + Caching)을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 LLM Apps in Production (RAG + Vector DB + Caching)은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.

“세션 관리와 컨텍스트 지속성” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 LLM Apps in Production (RAG + Vector DB + Caching) 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 LLM Apps in Production (RAG + Vector DB + Caching) 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

← LLM Apps in Production (RAG + Vector DB + Caching)(으)로 돌아가기