diff --git a/units/en/unit2/langgraph/when_to_use_langgraph.mdx b/units/en/unit2/langgraph/when_to_use_langgraph.mdx
index 28e1d850..2123e849 100644
--- a/units/en/unit2/langgraph/when_to_use_langgraph.mdx
+++ b/units/en/unit2/langgraph/when_to_use_langgraph.mdx
@@ -1,4 +1,4 @@
-# What is `LangGraph`?
+# What is `LangGraph`? [[what-is-langgraph]]
 
 `LangGraph` is a framework developed by [LangChain](https://www.langchain.com/) **to manage the control flow of applications that integrate an LLM**.
 
diff --git a/units/ko/_toctree.yml b/units/ko/_toctree.yml
index 124595ce..7a7e6da3 100644
--- a/units/ko/_toctree.yml
+++ b/units/ko/_toctree.yml
@@ -1,40 +1,106 @@
 - title: Unit 0. Welcome to the course
   sections:
   - local: unit0/introduction
-    title: Welcome to the course 🤗
+    title: AI 에이전트 코스에 오신걸 환영합니다 🤗
   - local: unit0/onboarding
-    title: Onboarding
+    title: 온보딩(Onboarding), 첫 걸음 내딛기 ⛵
   - local: unit0/discord101
-    title: (Optional) Discord 101
+    title: (선택) Discord 101
 - title: Unit 1. Introduction to Agents
   sections:
   - local: unit1/introduction
-    title: Introduction
+    title: 에이전트 소개
   - local: unit1/what-are-agents
-    title: What is an Agent?
+    title: 에이전트란?
   - local: unit1/quiz1
     title: Quick Quiz 1
   - local: unit1/what-are-llms
-    title: What are LLMs?
+    title: LLM이란?
   - local: unit1/messages-and-special-tokens
-    title: Messages and Special Tokens
+    title: 메세지와 특수 토큰
   - local: unit1/tools
-    title: What are Tools?
+    title: 도구란?
   - local: unit1/quiz2
     title: Quick Quiz 2
   - local: unit1/agent-steps-and-structure
-    title: Understanding AI Agents through the Thought-Action-Observation Cycle
+    title: 사고-행동-관찰 주기를 통해 AI 에이전트 이해하기
   - local: unit1/thoughts
-    title: Thought, Internal Reasoning and the Re-Act Approach
+    title: 사고, AI 에이전트의 내부 추론과 Re-Act 방식
   - local: unit1/actions
-    title: Actions, Enabling the Agent to Engage with Its Environment
+    title: 액션, 에이전트가 환경과 상호작용할 수 있게 하기
   - local: unit1/observations
-    title: Observe, Integrating Feedback to Reflect and Adapt
+    title: 관찰, 피드백을 통합하여 성찰하고 적응하기
   - local: unit1/dummy-agent-library
-    title: Dummy Agent Library
+    title: 더미 에이전트 라이브러리
   - local: unit1/tutorial
-    title: Let’s Create Our First Agent Using smolagents
+    title: smolagents로 첫 번째 에이전트 만들기
   - local: unit1/final-quiz
     title: Unit 1 Final Quiz
   - local: unit1/conclusion
     title: Conclusion
+- title: Unit 2. Frameworks for AI Agents
+  sections:
+  - local: unit2/introduction
+    title: AI Agent 프레임워크 소개
+- title: Unit 2.1 The smolagents framework
+  sections:
+  - local: unit2/smolagents/introduction
+    title: smolagents 소개
+  - local: unit2/smolagents/why_use_smolagents
+    title: smolagents를 왜 사용할까?
+  - local: unit2/smolagents/quiz1
+    title: Quick Quiz 1
+  - local: unit2/smolagents/code_agents
+    title: 코드를 사용하는 에이전트 만들기
+  - local: unit2/smolagents/tool_calling_agents
+    title: 액션을 코드 조각(코드 스니펫)이나 JSON 블롭으로 작성하기
+  - local: unit2/smolagents/tools
+    title: Tool 도구 소개
+  - local: unit2/smolagents/retrieval_agents
+    title: 검색 에이전트
+  - local: unit2/smolagents/quiz2
+    title: Quick Quiz 2
+  - local: unit2/smolagents/multi_agent_systems
+    title: 멀티 에이전트 시스템
+  - local: unit2/smolagents/vision_agents
+    title: 비전과 브라우저 에이전트
+  - local: unit2/smolagents/final_quiz
+    title: 최종 Quiz
+  - local: unit2/smolagents/conclusion
+    title: 결론
+- title: Unit 2.2 The LlamaIndex framework
+  sections:
+  - local: unit2/llama-index/introduction
+    title: LLamaIndex 소개
+  - local: unit2/llama-index/llama-hub
+    title: LlamaHub 소개
+  - local: unit2/llama-index/components
+    title: LlamaIndex의 구성 요소
+  - local: unit2/llama-index/tools
+    title: LlamaIndex에서 도구 사용하기
+  - local: unit2/llama-index/quiz1
+    title: Quick Quiz 1
+  - local: unit2/llama-index/agents
+    title: LlamaIndex에서 에이전트 사용하기
+  - local: unit2/llama-index/workflows
+    title: LlamaIndex에서 에이전트 워크플로우 만들기
+  - local: unit2/llama-index/quiz2
+    title: Quick Quiz 2
+  - local: unit2/llama-index/conclusion
+    title: 결론
+- title: Unit 2.3 The LangGraph framework
+  sections:
+  - local: unit2/langgraph/introduction
+    title: LangGraph 소개
+  - local: unit2/langgraph/when_to_use_langgraph
+    title: LangGraph란?
+  - local: unit2/langgraph/building_blocks
+    title: LangGraph의 구성 요소
+  - local: unit2/langgraph/first_graph
+    title: 첫 번째 LangGraph 만들기
+  - local: unit2/langgraph/document_analysis_agent
+    title: Document Analysis Graph
+  - local: unit2/langgraph/quiz1
+    title: Quick Quiz 1
+  - local: unit2/langgraph/conclusion
+    title: Conclusion
diff --git a/units/ko/unit2/introduction.mdx b/units/ko/unit2/introduction.mdx
new file mode 100644
index 00000000..e19d397c
--- /dev/null
+++ b/units/ko/unit2/introduction.mdx
@@ -0,0 +1,40 @@
+# 에이전틱 프레임워크 소개
+
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/thumbnail.jpg" alt="Thumbnail"/>
+
+Unit 2에 오신 것을 환영합니다! **이번 유닛에서는 다양한 에이전틱 프레임워크**를 살펴보고, 이를 활용해 강력한 에이전트 기반 애플리케이션을 만드는 방법을 배웁니다.
+
+이번 유닛에서 다룰 내용은 다음과 같습니다:
+
+- 2.1: [smolagents](https://huggingface.co/docs/smolagents/en/index)  
+- 2.2: [LlamaIndex](https://www.llamaindex.ai/)
+- 2.3: [LangGraph](https://www.langchain.com/langgraph)
+
+함께 시작해봅시다! 🕵
+
+## 에이전틱 프레임워크는 언제 필요할까?
+
+에이전틱 프레임워크는 **LLM 기반 애플리케이션을 만들 때 항상 필요한 것은 아닙니다.** 프레임워크는 특정 작업을 효율적으로 해결할 수 있도록 워크플로우에 유연성을 제공하지만, 항상 필수적인 것은 아닙니다.
+
+때로는 **미리 정의된 워크플로우만으로도** 사용자 요청을 충분히 처리할 수 있으며, 굳이 에이전틱 프레임워크가 필요하지 않을 수 있습니다. 에이전트 구조가 단순하다면, 프롬프트 체이닝 등 일반 코드만으로도 충분합니다. 이 경우 개발자는 **추상화 없이 시스템을 완전히 이해하고 제어**할 수 있다는 장점이 있습니다.
+
+하지만 워크플로우가 복잡해져 LLM이 함수를 호출하거나, 여러 에이전트를 활용해야 하는 경우에는 이러한 추상화가 도움이 되기 시작합니다.
+
+이러한 점을 고려하면, 다음과 같은 기능이 필요함을 알 수 있습니다:
+
+* 시스템을 구동할 *LLM 엔진*
+* 에이전트가 접근할 수 있는 *도구 목록*  
+* LLM 출력에서 도구 호출을 추출하는 *파서*
+* 파서와 동기화된 *시스템 프롬프트*
+* *메모리 시스템*
+* LLM의 실수를 제어할 *에러 로깅 및 재시도 메커니즘*
+
+이러한 주제들이 각 프레임워크에서 어떻게 해결되는지, `smolagents`, `LlamaIndex`, `LangGraph`를 통해 살펴볼 예정입니다.
+
+## 에이전틱 프레임워크별 유닛 안내
+
+| 프레임워크  | 설명 | 유닛 저자 |
+|------------|----------------|----------------|
+| [smolagents](./smolagents/introduction) | Hugging Face에서 개발한 에이전트 프레임워크 | Sergio Paniego - [HF](https://huggingface.co/sergiopaniego) - [X](https://x.com/sergiopaniego) - [Linkedin](https://www.linkedin.com/in/sergio-paniego-blanco) |
+| [Llama-Index](./llama-index/introduction) | 컨텍스트 증강 AI 에이전트를 프로덕션에 배포할 수 있는 엔드-투-엔드 툴링 | David Berenstein - [HF](https://huggingface.co/davidberenstein1957) - [X](https://x.com/davidberenstei) - [Linkedin](https://www.linkedin.com/in/davidberenstein) |
+| [LangGraph](./langgraph/introduction) | 상태 기반 에이전트 오케스트레이션을 지원하는 프레임워크 | Joffrey THOMAS - [HF](https://huggingface.co/Jofthomas) - [X](https://x.com/Jthmas404) - [Linkedin](https://www.linkedin.com/in/joffrey-thomas) |
diff --git a/units/ko/unit2/langgraph/building_blocks.mdx b/units/ko/unit2/langgraph/building_blocks.mdx
new file mode 100644
index 00000000..f3331332
--- /dev/null
+++ b/units/ko/unit2/langgraph/building_blocks.mdx
@@ -0,0 +1,127 @@
+# LangGraph의 구성 요소[[building-blocks-of-langgraph]]
+
+LangGraph로 애플리케이션을 구축하려면 핵심 구성 요소를 이해해야 합니다. LangGraph 애플리케이션을 구성하는 기본 빌딩 블록을 살펴보겠습니다.
+
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/LangGraph/Building_blocks.png" alt="Building Blocks" width="70%"/>
+
+LangGraph 애플리케이션은 **진입점(entrypoint)**에서 시작하며, 실행 흐름에 따라 한 함수에서 다른 함수로 이동하다가 END에 도달합니다.
+
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/LangGraph/application.png" alt="Application"/>
+
+## 1. 상태[[state]]
+
+**상태(State)**는 LangGraph의 중심 개념입니다. 애플리케이션을 통해 흐르는 모든 정보를 나타냅니다. 
+
+```python
+from typing_extensions import TypedDict
+
+class State(TypedDict):
+    graph_state: str
+```
+
+상태는 **사용자 정의**이므로, 의사결정 과정에 필요한 모든 데이터를 포함하도록 신중하게 설계해야 합니다!
+
+> 💡 **팁:** 애플리케이션이 단계 간에 추적해야 할 정보가 무엇인지 신중하게 고민하세요.
+
+## 2. 노드[[nodes]]
+
+**노드(Node)**는 파이썬 함수입니다. 각 노드는:
+- 상태를 입력으로 받습니다
+- 작업을 수행합니다
+- 상태 업데이트를 반환합니다
+
+```python
+def node_1(state):
+    print("---Node 1---")
+    return {"graph_state": state['graph_state'] +" I am"}
+
+def node_2(state):
+    print("---Node 2---")
+    return {"graph_state": state['graph_state'] +" happy!"}
+
+def node_3(state):
+    print("---Node 3---")
+    return {"graph_state": state['graph_state'] +" sad!"}
+```
+
+예를 들어, 노드는 다음과 같은 역할을 할 수 있습니다:
+- **LLM 호출**: 텍스트 생성 또는 의사결정
+- **툴 호출**: 외부 시스템과 상호작용
+- **조건부 로직**: 다음 단계 결정
+- **사람 개입**: 사용자 입력 받기
+
+> 💡 **정보:** START와 END처럼 전체 워크플로우에 필수적인 일부 노드는 langGraph에서 직접 제공합니다. 
+
+
+## 3. 엣지[[edges]]
+
+**엣지(Edge)**는 노드를 연결하며, 그래프 내에서 가능한 경로를 정의합니다:
+
+```python
+import random
+from typing import Literal
+
+def decide_mood(state) -> Literal["node_2", "node_3"]:
+    
+    # 종종 상태를 사용해 다음에 방문할 노드를 결정합니다
+    user_input = state['graph_state'] 
+    
+    # 여기서는 노드 2, 3 사이를 50:50으로 분기합니다
+    if random.random() < 0.5:
+
+        # 50% 확률로 Node 2 반환
+        return "node_2"
+    
+    # 50% 확률로 Node 3 반환
+    return "node_3"
+```
+
+엣지는 다음과 같이 나뉩니다:
+- **직접(Direct)**: 항상 노드 A에서 노드 B로 이동
+- **조건부(Conditional)**: 현재 상태에 따라 다음 노드를 선택
+
+## 4. StateGraph[[stategraph]]
+
+**StateGraph**는 전체 에이전트 워크플로우를 담는 컨테이너입니다:
+
+```python
+from IPython.display import Image, display
+from langgraph.graph import StateGraph, START, END
+
+# 그래프 생성
+builder = StateGraph(State)
+builder.add_node("node_1", node_1)
+builder.add_node("node_2", node_2)
+builder.add_node("node_3", node_3)
+
+# 로직 정의
+builder.add_edge(START, "node_1")
+builder.add_conditional_edges("node_1", decide_mood)
+builder.add_edge("node_2", END)
+builder.add_edge("node_3", END)
+
+# 그래프 컴파일
+graph = builder.compile()
+```
+
+이제 시각화할 수 있습니다! 
+```python
+# 시각화
+display(Image(graph.get_graph().draw_mermaid_png()))
+```
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/LangGraph/basic_graph.jpeg" alt="Graph Visualization"/>
+
+하지만 가장 중요한 것은 실제로 호출하는 것입니다:
+```python
+graph.invoke({"graph_state" : "Hi, this is Lance."})
+```
+출력 :
+```
+---Node 1---
+---Node 3---
+{'graph_state': 'Hi, this is Lance. I am sad!'}
+```
+
+## 다음 단계[[what's-next]]
+
+다음 섹션에서는 이러한 개념을 실제로 적용하여 첫 번째 그래프를 만들어보겠습니다. 이 그래프는 Alfred가 이메일을 받아 분류하고, 정상 메일이라면 임시 답장을 작성할 수 있도록 합니다.
diff --git a/units/ko/unit2/langgraph/conclusion.mdx b/units/ko/unit2/langgraph/conclusion.mdx
new file mode 100644
index 00000000..8bc1b483
--- /dev/null
+++ b/units/ko/unit2/langgraph/conclusion.mdx
@@ -0,0 +1,20 @@
+# 결론[[conclusion]]
+
+2단원의 LangGraph 모듈을 완료하신 것을 축하합니다! 🥳
+
+이제 LangGraph로 구조화된 워크플로우를 구축하는 기본기를 마스터하셨으며, 이를 실제 프로덕션 환경에 적용할 수 있습니다.
+
+이 모듈은 LangGraph 여정의 시작에 불과합니다. 심화 주제를 원하시는 분들을 위해 추천드립니다:
+
+- [공식 LangGraph 문서](https://github.com/langchain-ai/langgraph) 탐색
+- LangChain 아카데미의 종합적인 [LangGraph 소개](https://academy.langchain.com/courses/intro-to-langgraph) 강의 수강
+- 직접 무언가를 만들어보세요!
+
+다음 단원에서는 실제 사용 사례를 탐구합니다. 이제 이론을 넘어 실전으로 나아갈 시간입니다!
+
+**여러분의 강의에 대한 생각과 제안 사항들을 매우 환영합니다**. 피드백이 있으시면 👉 [이 양식](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog)을 작성해주세요!
+
+### 존경하는 여러분! 🎩🦇
+배움을 멈추지 마세요 🤗
+
+-알프레드-
\ No newline at end of file
diff --git a/units/ko/unit2/langgraph/document_analysis_agent.mdx b/units/ko/unit2/langgraph/document_analysis_agent.mdx
new file mode 100644
index 00000000..5a7a8b39
--- /dev/null
+++ b/units/ko/unit2/langgraph/document_analysis_agent.mdx
@@ -0,0 +1,267 @@
+# 문서 분석 그래프[[document-analysis-graph]]
+
+저 알프레드는 Mr.웨인님의 신뢰받는 집사로서, 그분의 다양한 문서 업무를 어떻게 지원할지 기록해두었습니다. 그가 밤 활동을 하러 나간 동안, 저는 모든 서류, 훈련 일정, 영양 계획을 분석하고 정리합니다.
+
+그분이 외출하기 전, 이번 주 훈련 프로그램이 적힌 쪽지를 남기셨습니다. 그 쪽지를 보고 저는 내일 식사를 위한 **메뉴**를 직접 짜기로 했죠.
+
+앞으로도 이런 일이 있을 때를 대비해, LangGraph를 활용해 웨인님을 위한 문서 분석 시스템을 만들어봅시다. 이 시스템은 다음을 수행 할 수 있습니다:
+
+1. 이미지 문서 처리
+2. 비전 모델(비전 언어 모델)로 텍스트 추출
+3. 필요시 계산 수행(일반 툴 시연)
+4. 내용 분석 및 요약 제공
+5. 문서 관련 특정 지시 실행
+
+## 집사의 워크플로우[[the-butler's-workflow]]
+
+만들 워크플로우의 구조는 다음과 같습니다:
+
+![집사의 문서 분석 워크플로우](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/LangGraph/alfred_flow.png)
+
+<Tip>
+<a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/langgraph/agent.ipynb" target="_blank">이 노트북</a>을 따라가며 Google Colab에서 코드를 실행해볼 수 있습니다.
+</Tip>
+
+## 환경 설정[[setting-up-the-environment]]
+
+```python
+%pip install langgraph langchain_openai langchain_core
+```
+임포트 :
+```python
+import base64
+from typing import List, TypedDict, Annotated, Optional
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import AnyMessage, SystemMessage, HumanMessage
+from langgraph.graph.message import add_messages
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import ToolNode, tools_condition
+from IPython.display import Image, display
+```
+
+## 에이전트 상태 정의[[defining-agent's-state]]
+
+이 상태는 앞서 본 것보다 조금 더 복잡합니다.
+`AnyMessage`는 Langchain의 메시지 클래스이고, `add_messages`는 최신 메시지를 누적하는 연산자입니다.
+
+LangGraph에서는 상태에 연산자를 추가해 상호작용 방식을 정의할 수 있습니다.
+
+```python
+class AgentState(TypedDict):
+    # 제공된 문서
+    input_file: Optional[str]  # 파일 경로(PDF/PNG)
+    messages: Annotated[list[AnyMessage], add_messages]
+```
+
+## 툴 준비하기[[preparing-tools]]
+
+```python
+vision_llm = ChatOpenAI(model="gpt-4o")
+
+def extract_text(img_path: str) -> str:
+    """
+    멀티모달 모델로 이미지 파일에서 텍스트 추출
+    
+    Wayne 주인님은 종종 훈련 일정이나 식단이 적힌 쪽지를 남깁니다.
+    이 기능으로 내용을 제대로 분석할 수 있습니다.
+    """
+    all_text = ""
+    try:
+        # 이미지를 읽고 base64로 인코딩
+        with open(img_path, "rb") as image_file:
+            image_bytes = image_file.read()
+
+        image_base64 = base64.b64encode(image_bytes).decode("utf-8")
+
+        # base64 이미지 데이터를 포함한 프롬프트 준비
+        message = [
+            HumanMessage(
+                content=[
+                    {
+                        "type": "text",
+                        "text": (
+                            "이 이미지에서 모든 텍스트를 추출하세요. 설명 없이 추출된 텍스트만 반환하세요."
+                        ),
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/png;base64,{image_base64}"
+                        },
+                    },
+                ]
+            )
+        ]
+
+        # 비전 모델 호출
+        response = vision_llm.invoke(message)
+
+        # 추출된 텍스트 추가
+        all_text += response.content + "\n\n"
+
+        return all_text.strip()
+    except Exception as e:
+        # 집사는 오류도 우아하게 처리해야 합니다
+        error_msg = f"텍스트 추출 오류: {str(e)}"
+        print(error_msg)
+        return ""
+
+def divide(a: int, b: int) -> float:
+    """주인님의 계산 요청을 위한 나눗셈 함수"""
+    return a / b
+
+# 집사, 도구(tool) 장착
+tools = [
+    divide,
+    extract_text
+]
+
+llm = ChatOpenAI(model="gpt-4o")
+llm_with_tools = llm.bind_tools(tools, parallel_tool_calls=False)
+```
+
+## 노드[[the-nodes]]
+
+```python
+def assistant(state: AgentState):
+    # 시스템 메시지
+    textual_description_of_tool="""
+extract_text(img_path: str) -> str:
+    멀티모달 모델로 이미지 파일에서 텍스트 추출
+
+    Args:
+        img_path: 로컬 이미지 파일 경로(문자열)
+
+    Returns:
+        각 이미지에서 추출된 텍스트를 합친 문자열
+divide(a: int, b: int) -> float:
+    a를 b로 나눔
+"""
+    image=state["input_file"]
+    sys_msg = SystemMessage(content=f"당신은 Mr. Wayne과 배트맨을 섬기는 친절한 집사 알프레드입니다. 아래 툴로 문서를 분석하고 계산을 수행할 수 있습니다:\n{textual_description_of_tool} \n 현재 로드된 이미지는: {image}")
+
+    return {
+        "messages": [llm_with_tools.invoke([sys_msg] + state["messages"])],
+        "input_file": state["input_file"]
+    }
+```
+
+## ReAct 패턴: 집사의 지원 방식[[the-react-pattern-how-i-assist-mr.-wayne]]
+
+이 에이전트는 ReAct 패턴(Reason-Act-Observe)을 따릅니다.
+
+1. 문서와 요청을 **이해(Reason)**
+2. 적절한 툴을 **실행(Act)**
+3. 결과를 **관찰(Observe)**
+4. 필요시 반복
+
+아주 간단한 LangGraph 에이전트 구현 예시입니다.
+
+```python
+# 그래프 생성
+builder = StateGraph(AgentState)
+
+# 노드 정의: 실제 작업을 수행
+builder.add_node("assistant", assistant)
+builder.add_node("tools", ToolNode(tools))
+
+# 엣지 정의: 제어 흐름 결정
+builder.add_edge(START, "assistant")
+builder.add_conditional_edges(
+    "assistant",
+    # 최신 메시지가 툴을 필요로 하면 tools로 라우팅
+    # 아니면 직접 응답
+    tools_condition,
+)
+builder.add_edge("tools", "assistant")
+react_graph = builder.compile()
+
+# 집사의 사고 과정을 시각화
+display(Image(react_graph.get_graph(xray=True).draw_mermaid_png()))
+```
+
+`tools` 노드는 툴 리스트를, `assistant` 노드는 툴이 바인딩된 모델을 의미합니다.
+그래프에는 `assistant`와 `tools` 노드가 있습니다.
+
+`tools_condition` 엣지는 모델이 툴을 호출하면 tools로, 아니면 End로 흐름을 보냅니다.
+
+이제 한 단계 더 추가합니다:
+
+`tools` 노드를 다시 `assistant`로 연결해 루프를 만듭니다.
+
+- `assistant` 노드 실행 후, `tools_condition`이 모델 출력이 툴 호출인지 확인합니다.
+- 툴 호출이면 흐름이 `tools` 노드로 이동합니다.
+- `tools` 노드는 다시 `assistant`로 연결됩니다.
+- 이 루프는 모델이 툴 호출을 결정하는 한 계속됩니다.
+- 모델 응답이 툴 호출이 아니면 흐름이 END로 이동해 프로세스가 종료됩니다.
+
+![ReAct 패턴](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/LangGraph/Agent.png)
+
+## 집사의 실제 활용 예시[[the-butler-in-action]]
+
+### 예시 1: 간단한 계산[[example-1-simple-calculations]]
+
+아래는 LangGraph에서 툴을 사용하는 간단한 예시입니다.
+
+```python
+messages = [HumanMessage(content="6790을 5로 나눠줘")]
+messages = react_graph.invoke({"messages": messages, "input_file": None})
+
+# 메시지 출력
+for m in messages['messages']:
+    m.pretty_print()
+```
+
+대화 예시:
+
+```
+Human: 6790을 5로 나눠줘
+
+AI Tool Call: divide(a=6790, b=5)
+
+Tool Response: 1358.0
+
+Alfred: 6790을 5로 나누면 1358.0입니다.
+```
+
+### 예시 2: Wayne 주인님의 훈련 문서 분석[[example-2-analyzing-master-wayne's-training-documents]]
+
+주인님이 훈련 및 식단 쪽지를 남겼을 때:
+
+```python
+messages = [HumanMessage(content="제공된 이미지에 있는 Wayne 주인님의 쪽지에 따라 저녁 메뉴에 필요한 재료 목록을 알려줘.")]
+messages = react_graph.invoke({"messages": messages, "input_file": "Batman_training_and_meals.png"})
+```
+
+대화 예시:
+
+```
+Human: 제공된 이미지에 있는 Wayne 주인님의 쪽지에 따라 저녁 메뉴에 필요한 재료 목록을 알려줘.
+
+AI Tool Call: extract_text(img_path="Batman_training_and_meals.png")
+
+Tool Response: [훈련 일정 및 메뉴 세부 정보가 추출됨]
+
+Alfred: 저녁 메뉴를 위해 다음 재료를 구입하세요:
+
+1. 목초 사육 소고기 등심 스테이크
+2. 유기농 시금치
+3. 피키요 고추
+4. 감자(오븐에 구울 허브 감자용)
+5. 피쉬 오일(2그램)
+
+스테이크는 목초 사육, 시금치와 고추는 유기농으로 준비하면 최고의 식사가 됩니다.
+```
+
+## 핵심 요약[[key-takeaways]]
+
+나만의 문서 분석 집사를 만들고 싶다면 다음을 고려하세요:
+
+1. **문서 관련 작업별로 명확한 툴 정의**
+2. **툴 호출 간 맥락 유지를 위한 견고한 상태 추적기**
+3. **툴 실패 시 오류 처리 고려**
+4. **이전 상호작용 맥락 유지(add_messages 연산자 활용)**
+
+이 원칙을 따르면 Wayne 저택에 어울리는 문서 분석 서비스를 제공할 수 있습니다.
+
+*이 설명이 도움이 되었길 바랍니다. 이제 주인님의 망토를 다림질하러 가보겠습니다.*
diff --git a/units/ko/unit2/langgraph/first_graph.mdx b/units/ko/unit2/langgraph/first_graph.mdx
new file mode 100644
index 00000000..e51d0f43
--- /dev/null
+++ b/units/ko/unit2/langgraph/first_graph.mdx
@@ -0,0 +1,343 @@
+# 나만의 첫 LangGraph 만들기[[building-your-first-langgraph]]
+
+이제 LangGraph의 구성 요소를 이해했으니, 실제로 적용해보며 첫 번째 기능적 그래프를 만들어봅시다. 여기서는 알프레드의 이메일 처리 시스템을 구현할 것입니다. 알프레드는 다음과 같은 작업을 수행해야 합니다:
+
+1. 들어오는 이메일 읽기
+2. 스팸 또는 정상 메일로 분류하기
+3. 정상 메일에 대한 임시 답장 작성하기
+4. 정상 메일일 경우 Mr. Wayne에게 정보 전달(출력만)
+
+이 예제는 LLM 기반 의사결정이 포함된 LangGraph 워크플로우 구조화 방법을 보여줍니다. (여기서는 별도의 툴이 사용되지 않으므로 Agent라고 부르진 않지만, LangGraph 프레임워크 학습에 초점을 둡니다.)
+
+<Tip>
+<a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/langgraph/mail_sorting.ipynb" target="_blank">이 노트북</a>을 따라가며 Google Colab에서 코드를 실행해볼 수 있습니다.
+</Tip>
+
+## 우리가 만들 워크플로우[[our-workflow]]
+
+아래와 같은 워크플로우를 구현합니다:
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/LangGraph/first_graph.png" alt="First LangGraph"/>
+
+## 환경 설정[[setting-up-our-environment]]
+
+먼저 필요한 패키지를 설치합니다:
+
+```python
+%pip install langgraph langchain_openai
+```
+
+필요한 모듈을 임포트합니다:
+
+```python
+import os
+from typing import TypedDict, List, Dict, Any, Optional
+from langgraph.graph import StateGraph, START, END
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage
+```
+
+## 1단계: 상태(State) 정의하기[[step-1-define-our-state]]
+
+이메일 처리 워크플로우에서 알프레드가 추적해야 할 정보를 정의합니다:
+
+```python
+class EmailState(TypedDict):
+    # 처리 중인 이메일
+    email: Dict[str, Any]  # 제목, 발신자, 본문 등 포함
+
+    # 이메일 분류(문의, 불만 등)
+    email_category: Optional[str]
+
+    # 스팸으로 분류된 이유
+    spam_reason: Optional[str]
+
+    # 분석 및 결정
+    is_spam: Optional[bool]
+    
+    # 답장 생성
+    email_draft: Optional[str]
+    
+    # 처리 메타데이터
+    messages: List[Dict[str, Any]]  # LLM과의 대화 추적
+```
+
+> 💡 **팁:** 상태는 중요한 정보를 모두 담되, 불필요하게 비대해지지 않도록 하세요.
+
+## 2단계: 노드 정의하기[[step-2-define-our-nodes]]
+
+이제 각 처리 단계를 담당할 함수를 만듭니다:
+
+```python
+# LLM 초기화
+model = ChatOpenAI(temperature=0)
+
+def read_email(state: EmailState):
+    """알프레드가 들어온 이메일을 읽고 기록합니다."""
+    email = state["email"]
+    print(f"알프레드가 {email['sender']}로부터 온 메일(제목: {email['subject']})을 처리 중입니다.")
+    return {}
+
+def classify_email(state: EmailState):
+    """알프레드가 LLM을 사용해 이메일을 스팸/정상으로 분류합니다."""
+    email = state["email"]
+    prompt = f"""
+    집사 알프레드로서, 이 이메일을 분석해 스팸인지 정상인지 판단하세요.
+    
+    이메일:
+    From: {email['sender']}
+    Subject: {email['subject']}
+    Body: {email['body']}
+    
+    먼저 이 이메일이 스팸인지 판단하고, 스팸이라면 그 이유를 설명하세요.
+    정상 메일이라면 (문의, 불만, 감사, 요청 등) 카테고리도 분류하세요.
+    """
+    messages = [HumanMessage(content=prompt)]
+    response = model.invoke(messages)
+    response_text = response.content.lower()
+    is_spam = "spam" in response_text and "not spam" not in response_text
+    spam_reason = None
+    if is_spam and "reason:" in response_text:
+        spam_reason = response_text.split("reason:")[1].strip()
+    email_category = None
+    if not is_spam:
+        categories = ["inquiry", "complaint", "thank you", "request", "information"]
+        for category in categories:
+            if category in response_text:
+                email_category = category
+                break
+    new_messages = state.get("messages", []) + [
+        {"role": "user", "content": prompt},
+        {"role": "assistant", "content": response.content}
+    ]
+    return {
+        "is_spam": is_spam,
+        "spam_reason": spam_reason,
+        "email_category": email_category,
+        "messages": new_messages
+    }
+
+def handle_spam(state: EmailState):
+    """알프레드가 스팸 메일을 처리합니다."""
+    print(f"알프레드는 이 메일을 스팸으로 분류했습니다. 이유: {state['spam_reason']}")
+    print("이 메일은 스팸 폴더로 이동되었습니다.")
+    return {}
+
+def draft_response(state: EmailState):
+    """알프레드가 정상 메일에 임시 답장을 작성합니다."""
+    email = state["email"]
+    category = state["email_category"] or "일반"
+    prompt = f"""
+    집사 알프레드로서, 이 이메일에 정중한 임시 답장을 작성하세요.
+    
+    이메일:
+    From: {email['sender']}
+    Subject: {email['subject']}
+    Body: {email['body']}
+    
+    이 이메일의 카테고리: {category}
+    
+    Mr. Hugg가 검토 후 개인화할 수 있도록 간단하고 전문적인 답장을 작성하세요.
+    """
+    messages = [HumanMessage(content=prompt)]
+    response = model.invoke(messages)
+    new_messages = state.get("messages", []) + [
+        {"role": "user", "content": prompt},
+        {"role": "assistant", "content": response.content}
+    ]
+    return {
+        "email_draft": response.content,
+        "messages": new_messages
+    }
+
+def notify_mr_hugg(state: EmailState):
+    """알프레드가 Mr. Hugg에게 메일과 임시 답장을 전달합니다."""
+    email = state["email"]
+    print("\n" + "="*50)
+    print(f"주인님, {email['sender']}로부터 메일이 도착했습니다.")
+    print(f"제목: {email['subject']}")
+    print(f"카테고리: {state['email_category']}")
+    print("\n검토하실 임시 답장을 준비했습니다:")
+    print("-"*50)
+    print(state["email_draft"])
+    print("="*50 + "\n")
+    return {}
+```
+
+## 3단계: 분기 로직 정의하기[[step-3-define-our-routing-logic]]
+
+분류 후 어떤 경로로 갈지 결정하는 함수를 만듭니다:
+
+```python
+def route_email(state: EmailState) -> str:
+    """스팸 분류 결과에 따라 다음 단계를 결정합니다."""
+    if state["is_spam"]:
+        return "spam"
+    else:
+        return "legitimate"
+```
+
+> 💡 **참고:** 이 라우팅 함수는 LangGraph가 분류 노드 이후 어떤 엣지를 따라갈지 결정할 때 호출됩니다. 반환값은 조건부 엣지 매핑의 키와 일치해야 합니다.
+
+## 4단계: StateGraph 생성 및 엣지 정의[[step-4-create-the-stategraph-and-define-edges]]
+
+이제 모든 것을 연결합니다:
+
+```python
+# 그래프 생성
+email_graph = StateGraph(EmailState)
+
+# 노드 추가
+email_graph.add_node("read_email", read_email)
+email_graph.add_node("classify_email", classify_email)
+email_graph.add_node("handle_spam", handle_spam)
+email_graph.add_node("draft_response", draft_response)
+email_graph.add_node("notify_mr_hugg", notify_mr_hugg)
+
+# 엣지 시작
+email_graph.add_edge(START, "read_email")
+# 흐름 정의
+email_graph.add_edge("read_email", "classify_email")
+
+# 분기 추가
+email_graph.add_conditional_edges(
+    "classify_email",
+    route_email,
+    {
+        "spam": "handle_spam",
+        "legitimate": "draft_response"
+    }
+)
+
+# 마지막 엣지
+email_graph.add_edge("handle_spam", END)
+email_graph.add_edge("draft_response", "notify_mr_hugg")
+email_graph.add_edge("notify_mr_hugg", END)
+
+# 그래프 컴파일
+compiled_graph = email_graph.compile()
+```
+
+LangGraph에서 제공하는 특수한 `END` 노드를 사용합니다. 이는 워크플로우가 완료되는 지점을 나타냅니다.
+
+## 5단계: 어플리케이션 실행하기[[step-5-run-the-application]]
+
+정상 메일과 스팸 메일로 그래프를 테스트해봅니다:
+
+```python
+# 정상 메일 예시
+legitimate_email = {
+    "sender": "john.smith@example.com",
+    "subject": "서비스 문의",
+    "body": "안녕하세요 Mr. Hugg, 동료의 추천으로 연락드립니다. 귀하의 컨설팅 서비스에 대해 더 알고 싶습니다. 다음 주에 통화 가능할까요? 감사합니다, John Smith"
+}
+
+# 스팸 메일 예시
+spam_email = {
+    "sender": "winner@lottery-intl.com",
+    "subject": "당신은 $5,000,000에 당첨되었습니다!!!",
+    "body": "축하합니다! 국제 복권에 당첨되셨습니다! 상금을 받으시려면 은행 정보와 수수료 $100을 보내주세요."
+}
+
+# 정상 메일 처리
+print("\n정상 메일 처리 중...")
+legitimate_result = compiled_graph.invoke({
+    "email": legitimate_email,
+    "is_spam": None,
+    "spam_reason": None,
+    "email_category": None,
+    "email_draft": None,
+    "messages": []
+})
+
+# 스팸 메일 처리
+print("\n스팸 메일 처리 중...")
+spam_result = compiled_graph.invoke({
+    "email": spam_email,
+    "is_spam": None,
+    "spam_reason": None,
+    "email_category": None,
+    "email_draft": None,
+    "messages": []
+})
+```
+
+## 6단계: Langfuse로 메일 분류 에이전트 관찰하기 📡[[step-6-inspecting-our-mail-sorting-agent-with-langfuse]]
+
+알프레드는 메일 분류 에이전트를 다듬으면서 디버깅에 지쳐갑니다. 에이전트는 본질적으로 예측 불가능하고 추적이 어렵기 때문입니다. 하지만 궁극의 스팸 감지 에이전트를 만들어 프로덕션에 배포하려면, 향후 모니터링과 분석을 위한 강력한 추적 기능이 필요합니다.
+
+이를 위해 알프레드는 [Langfuse](https://langfuse.com/)와 같은 관찰 도구를 사용할 수 있습니다.
+
+먼저 Langfuse를 설치합니다:
+```python
+%pip install -q langfuse
+```
+
+LangChain도 설치합니다(Langfuse 사용 시 필요):
+```python
+%pip install langchain
+```
+
+Langfuse API 키와 호스트 주소를 환경 변수로 추가합니다. [Langfuse Cloud](https://cloud.langfuse.com) 가입 또는 [셀프 호스팅](https://langfuse.com/self-hosting)으로 키를 발급받을 수 있습니다.
+
+```python
+import os
+# 프로젝트 설정 페이지에서 키를 확인하세요: https://cloud.langfuse.com
+os.environ["LANGFUSE_PUBLIC_KEY"] = "pk-lf-..."
+os.environ["LANGFUSE_SECRET_KEY"] = "sk-lf-..."
+os.environ["LANGFUSE_HOST"] = "https://cloud.langfuse.com" # 🇪🇺 EU 리전
+# os.environ["LANGFUSE_HOST"] = "https://us.cloud.langfuse.com" # 🇺🇸 US 리전
+```
+
+[Langfuse `callback_handler`](https://langfuse.com/docs/integrations/langchain/tracing#add-langfuse-to-your-langchain-application)를 설정하고, 그래프 호출 시 `config={"callbacks": [langfuse_handler]}`로 인스트루먼트합니다.
+
+```python   
+from langfuse.langchain import CallbackHandler
+
+# LangGraph/Langchain용 Langfuse CallbackHandler 초기화(추적용)
+langfuse_handler = CallbackHandler()
+
+# 정상 메일 처리
+legitimate_result = compiled_graph.invoke(
+    input={"email": legitimate_email, "is_spam": None, "spam_reason": None, "email_category": None, "draft_response": None, "messages": []},
+    config={"callbacks": [langfuse_handler]}
+)
+```
+
+이제 알프레드는 LangGraph의 실행 내역을 Langfuse에 기록하여 에이전트의 동작을 완전히 파악할 수 있습니다. 이로써 이전 실행을 다시 살펴보고 메일 분류 에이전트를 더욱 개선할 수 있습니다.
+
+![Langfuse 예시 트레이스](https://langfuse.com/images/cookbook/huggingface-agent-course/langgraph-trace-legit.png)
+
+_[정상 메일 트레이스 공개 링크](https://cloud.langfuse.com/project/cloramnkj0002jz088vzn1ja4/traces/f5d6d72e-20af-4357-b232-af44c3728a7b?timestamp=2025-03-17T10%3A13%3A28.413Z&observation=6997ba69-043f-4f77-9445-700a033afba1)_
+
+## 그래프 시각화[[visualizing-our-graph]]
+
+LangGraph는 워크플로우 구조를 시각화하여 이해와 디버깅을 돕습니다:
+
+```python
+compiled_graph.get_graph().draw_mermaid_png()
+```
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/LangGraph/mail_flow.png" alt="Mail LangGraph"/>
+
+이렇게 하면 노드 간 연결과 조건부 경로를 한눈에 볼 수 있습니다.
+
+## 우리가 만든 것[[what-we've-built]]
+
+우리는 다음과 같은 이메일 처리 워크플로우를 완성했습니다:
+
+1. 들어온 이메일을 받음
+2. LLM으로 스팸/정상 분류
+3. 스팸은 폐기
+4. 정상 메일은 답장 작성 후 Mr. Hugg에게 전달
+
+이처럼 LangGraph를 활용하면 LLM 기반의 복잡한 워크플로우도 명확하고 구조적으로 오케스트레이션할 수 있습니다.
+
+## 핵심 요약[[key-takeaways]]
+
+- **상태 관리**: 이메일 처리의 모든 측면을 추적할 수 있도록 상태를 정의
+- **노드 구현**: LLM과 상호작용하는 기능적 노드 구현
+- **조건부 분기**: 이메일 분류 결과에 따라 분기 로직 구현
+- **종료 상태**: END 노드로 워크플로우 종료 지점 표시
+
+## 다음 단계[[what's-next]]
+
+다음 섹션에서는 LangGraph의 고급 기능(사람과의 상호작용, 다중 조건 분기 등)을 다룹니다.
diff --git a/units/ko/unit2/langgraph/introduction.mdx b/units/ko/unit2/langgraph/introduction.mdx
new file mode 100644
index 00000000..a1f9da79
--- /dev/null
+++ b/units/ko/unit2/langgraph/introduction.mdx
@@ -0,0 +1,32 @@
+# `LangGraph` 소개[[introduction-to-langgraph]]
+
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/LangGraph/LangGraph.png" alt="Unit 2.3 Thumbnail"/>
+
+다음 단계에 오신 것을 환영합니다! 이 단원에서는 복잡한 LLM 워크플로우를 구조화하고 조정, 관리할 수 있도록 설계된 [`LangGraph`](https://github.com/langchain-ai/langgraph) 프레임워크를 사용하여 **어플리케이션을 구축하는 방법**을 배우게 됩니다.
+
+`LangGraph`는 에이전트의 흐름을 **직접 제어**할 수 있는 도구를 제공하여 **프로덕션 수준**의 어플리케이션을 만들 수 있게 해주는 프레임워크입니다.
+
+## 모듈 개요[[module-overview]]
+
+이 단원에서 여러분은 다음을 배우게 됩니다:
+
+### 1️⃣ [LangGraph란 무엇이며, 언제 사용해야 할까?](./when_to_use_langgraph)
+### 2️⃣ [LangGraph의 구성 요소](./building_blocks)
+### 3️⃣ [내 메일을 대신 분류해주는 집사](./first_graph)
+### 4️⃣ [알프레드, 문서 분석 에이전트](./document_analysis_agent)
+### 5️⃣ [퀴즈](./quizz1)
+
+<Tip warning={true}>
+이 섹션의 예제들은 강력한 LLM/VLM 모델이 필요합니다. 이 코스에서는 langGraph와 가장 호환성이 좋은 GPT-4o API를 사용해 실행하였습니다.
+</Tip>
+
+이 단원이 끝나면, 여러분은 견고하고 체계적인, 프로덕션에 바로 투입 가능한 어플리케이션을 만들 수 있게 됩니다!
+
+이 섹션은 LangGraph의 입문 과정이니, 더 심화된 주제는 무료 LangChain 아카데미 강의 [LangGraph 소개](https://academy.langchain.com/courses/intro-to-langgraph)에서 확인할 수 있습니다.
+
+그럼 시작해볼까요?
+
+## 참고 자료[[resources]]
+
+- [LangGraph Agents](https://langchain-ai.github.io/langgraph/) - LangGraph 에이전트 예제
+- [LangChain academy](https://academy.langchain.com/courses/intro-to-langgraph) - LangChain에서 제공하는 LangGraph 전체 강의
diff --git a/units/ko/unit2/langgraph/quiz1.mdx b/units/ko/unit2/langgraph/quiz1.mdx
new file mode 100644
index 00000000..2f8f9bb2
--- /dev/null
+++ b/units/ko/unit2/langgraph/quiz1.mdx
@@ -0,0 +1,118 @@
+# LangGraph 이해도 테스트 [[test-your-understanding-of-langgraph]]
+
+`LangGraph`에 대한 이해도를 간단한 퀴즈로 확인해보세요! 지금까지 배운 핵심 개념을 복습하는 데 도움이 됩니다.
+
+이 퀴즈는 선택 사항이며 채점되지 않습니다.
+
+### Q1: LangGraph의 주요 목적은 무엇인가요? [[q1-what-is-the-primary-purpose-of-langgraph]]
+LangGraph가 무엇을 위해 설계되었는지 가장 잘 설명하는 문장은?
+
+<Question
+choices={[
+  {
+    text: "LLM을 포함한 애플리케이션의 제어 흐름을 구축하기 위한 프레임워크",
+    explain: "LangGraph는 LLM을 사용하는 애플리케이션의 제어 흐름을 구축하고 관리하는 데 특화되어 있습니다.",
+    correct: true
+  },
+  {
+    text: "다양한 LLM 모델과 상호작용할 수 있는 인터페이스를 제공하는 라이브러리",
+    explain: "이 설명은 LangChain의 역할에 더 가깝습니다. LangChain은 모델과의 상호작용을 위한 표준 인터페이스를 제공하는 역할, LangGraph는 제어 흐름에 중점을 둡니다.",
+  },
+  {
+    text: "도구(툴)를 호출하기 위한 Agent 라이브러리",
+    explain: "LangGraph는 Agent와 함께 사용하는 것은 맞지만, LangGraph의 주요 목적은 '오케스트레이션(Orchestration)'입니다.",
+  }
+]}
+/>
+
+---
+
+### Q2: "제어 vs 자유" 관점에서 LangGraph는 어디에 속하나요? [[q2-in-the-context-of-the-control-vs-freedom-trade-off-where-does-langgraph-stand]]
+다음 중 LangGraph의 에이전트 설계 접근 방식을 가장 잘 설명한 문장은?
+
+<Question
+choices={[
+  {
+    text: "LangGraph는 LLM에게 자유도를 높게 주어 모든 결정을 독립적으로 내릴 수 있도록 합니다.",
+    explain: "LangGraph는 오히려 구조화된 워크플로우를 제공하여 LLM의 동작을 제어합니다.",
+  },
+  {
+    text: "LangGraph는 실행 흐름에 대한 강력한 제어를 제공하면서 동시에 의사결정을 위해 LLM 기능을 활용합니다",
+    explain: "LangGraph는 구조화된 워크플로우를 통해 에이전트의 실행을 예측 가능하게 하고, LLM의 결정을 활용할 수 있게 설계되어 있습니다."
+    correct: true
+  },
+]}
+/>
+
+---
+
+### Q3: LangGraph에서 상태(State)의 역할은 무엇인가요? [[q3-what-role-does-state-play-in-langgraph]]
+다음 중 LangGraph에서 상태(State)에 대한 설명으로 가장 적절한 것은?
+
+<Question
+choices={[
+  {
+    text: "상태(State)는 LLM이 생성한 것 중 가장 최신 결과입니다.",
+    explain: "상태(State)는 LangGraph에서 사용자가 정의한 클래스로, LLM이 생성한 것이 아닙니다. 사용자가 필드를 정의하고 그 값은 LLM이 채울 수 있습니다",
+  },
+  {
+    text: "상태(State)는 실행 중 발생한 오류를 추적하는 데만 사용됩니다",
+    explain: "상태는 오류 추적 외에도 다양한 목적으로도 사용됩니다. 물론 오류 추적 또한 유용하게 사용되는 예시입니다.",
+  },
+  {
+    text: "상태(State)는 에이전트 어플리케이션을 통해 흐르는 정보를 나타냅니다",
+    explain: "상태(State)는 LangGraph의 핵심적인 역할을 하며, 각 노드 간 의사결정에 필요한 모든 정보를 담고 있습니다. 사용자가 필요한 필드를 정의하면, 노드가 필드 값을 변경하며 흐름을 결정합니다.",
+    correct: true
+  },
+  {
+    text: "상태(State)는 외부 API와 작업할 때만 관련이 있습니다",
+    explain: "상태(State)는 외부 API와 작업하는 어플리케이션뿐만 아니라 모든 LangGraph 어플리케이션의 필수 요소입니다.",
+  }
+]}
+/>
+
+### Q4: LangGraph에서 조건부 엣지(Conditional Edge)란 무엇인가요? [[q4-what-is-a-conditional-edge-in-langgraph]]
+조건부 엣지에 대한 설명으로 가장 적절한 것은?
+
+<Question
+choices={[
+    {
+    text: "조건을 평가하여 다음에 실행할 노드를 결정하는 엣지",
+    explain: "조건부 엣지는 현재 상태(State)를 기반으로 그래프가 동적 라우팅을 수행하여 워크플로우에 분기 로직을 만듭니다.",
+    correct: true
+  },
+  {
+    text: "특정 조건이 발생할 때만 따라가는 엣지",
+    explain: "조건부 엣지는 어플리케이션의 입력이 아닌 출력을 기반으로 흐름을 제어합니다.",
+  },
+  {
+    text: "진행 전에 사용자 확인이 필요한 엣지",
+    explain: "조건부 엣지는 사용자 상호작용이 아닌, 프로그래밍 조건에 따라 동작합니다.",
+  }
+]}
+/>
+
+---
+
+### Q5: LangGraph는 LLM의 환각(hallucination) 문제를 어떻게 해결하는 데 도움이 되나요? [[q5-how-does-langgraph-help-address-the-hallucination-problem-in-llms]]
+환각에 대한 설명으로 가장 적절한 것은?
+
+<Question
+choices={[
+  {
+    text: "LangGraph는 LLM 응답을 제한하여 환각을 완전히 제거합니다",
+    explain: "어떤 프레임워크도 LLM의 환각을 완전히 제거할 수 없으며, LangGraph도 예외는 아닙니다.",
+  },
+  {
+    text: "LangGraph는 LLM 출력을 검증하고 확인할 수 있는 구조화된 워크플로우를 제공합니다",
+    explain: "LangGraph는 검증 단계, 확인 노드, 오류 처리 경로 등을 구조화한 워크플로우를 통해 환각의 영향을 줄이는데 도움을 줍니다.",
+    correct: true
+  },
+  {
+    text: "LangGraph는 환각에 영향을 주지 않습니다",
+    explain: "LangGraph는 구조화된 워크플로우를 통해, 속도를 희생하더라도 환각 완화에 효과적입니다.",
+  }
+]}
+/>
+
+축하합니다! 🎉 틀린 문제가 있다면, 앞에서 다룬 내용들을 다시 검토해보세요. 이제 LangGraph의 더 심화 기능을 알아보고, 더 복잡한 에이전트 워크플로우를 구축하는 방법을 배워봅시다.
diff --git a/units/ko/unit2/langgraph/when_to_use_langgraph.mdx b/units/ko/unit2/langgraph/when_to_use_langgraph.mdx
new file mode 100644
index 00000000..09370de2
--- /dev/null
+++ b/units/ko/unit2/langgraph/when_to_use_langgraph.mdx
@@ -0,0 +1,68 @@
+# `LangGraph`란 무엇인가요? [[what-is-langgraph]]
+
+`LangGraph`는 [LangChain](https://www.langchain.com/)에서 개발한 프레임워크로, **LLM을 통합한 어플리케이션의 제어 흐름을 관리**하기 위해 만들어졌습니다.
+
+## `LangGraph`는 `LangChain`와 어떻게 다른가요? [[is-langgraph-different-from-langchain]]
+
+LangChain은 모델 및 기타 구성 요소와 상호작용하기 위한 표준 인터페이스를 제공하며, 검색, LLM 호출, 툴 호출에 유용합니다.
+LangChain의 클래스들은 LangGraph에서 사용될 수 있지만, 반드시 사용해야 하는 것은 아닙니다.
+
+두 패키지는 서로 다른 패키지이며, 각각 독립적으로 사용할 수 있지만, 실제로 온라인에서 찾을 수 있는 대부분의 예제에서는 두 패키지를 함께 사용하는 경우가 많습니다.
+
+## 언제 `LangGraph`를 사용해야 할까요? [[when-should-i-use-langgraph]]
+### 제어 vs 자유 [[control-vs-freedom]]
+
+AI 어플리케이션을 설계할 때, **제어**와 **자유** 사이의 트레이드오프를 고려해야합니다:
+
+- **자유**는 LLM이 더 많은 창의성을 발휘하고 예상치 못한 문제를 해결할 수 있도록 합니다.
+- **제어**는 예측 가능한 동작을 보장하고 안전 장치를 유지할 수 있습니다.
+
+*smolagents*의 코드 에이전트는 매우 자유롭습니다. 하나의 액션 단계에서 여러 도구를 호출하거나, 자체적으로 도구를 만들기도 합니다. 하지만 이런 동작은 JSON 기반 에이전트보다 예측하기 어렵고 제어하기 어렵게 만듭니다!
+
+`LangGraph`는 스펙트럼의 반대편에 있으며, 에이전트 실행에 **"제어"**가 필요할 때 빛납니다.
+
+LangGraph는 특히 **어플리케이션에 대한 제어**가 필요할 때 가치가 있습니다. 예측 가능한 프로세스를 따르면서도 LLM의 힘을 활용할 수 있도록 돕는 도구를 제공합니다.
+
+간단히 말하면, 어플리케이션이 특정 방식으로 구성된 일련의 단계를 거쳐야하고, 각 분기점에서 의사결정이 내려져야 한다면, **LangGraph가 그 필요한 구조를 제공해줍니다**.
+
+예를 들어, 문서에 대한 질문에 답할 수 있는 LLM 어시스턴트를 구축하고 싶다고 가정해봅시다.
+
+LLM이 텍스트를 가장 잘 이해하기 때문에, 질문에 답하기 전에 복잡한 형태들(차트, 표)을 텍스트로 변환해야 합니다. 하지만 그 선택은 문서의 유형에 따라 달라집니다!
+
+이러한 분기 흐름은 아래와 같이 표현할 수 있습니다:
+
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/LangGraph/flow.png" alt="Control flow"/>
+
+> 💡 **팁:** 왼쪽 부분은 도구 호출이 없기 때문에 에이전트가 아닙니다. 그러나 오른쪽 부분은 엑셀 파일을 쿼리하기 위해 코드를 작성해야 하므로 에이전트가 필요합니다.(예: pandas로 변환하고 조작).
+
+이 분기는 결정적이지만, LLM 출력에 따라 조건이 정해지는 비결정적 분기도 설계할 수 있습니다.
+
+LangGraph가 유용한 경우:
+
+- **명시적인 흐름 제어가 필요한 다단계 추론 프로세스**
+- **단계 간 상태 지속이 필요한 어플리케이션**
+- **결정론적 로직과 AI 기능을 결합하는 시스템**
+- **사람의 개입이 필요한 워크플로우**
+- **여러 구성 요소가 함께 작동하는 복잡한 에이전트 아키텍처**
+
+요약하자면, 최대한 **사람이 직접** 각 단계의 출력에 따라 실행할 다음 단계를 설계해야 하는 경우, LangGraph가 가장 적절합니다!
+
+`LangGraph`는 제 생각에 시장에서 가장 프로덕션 준비가 잘 된 에이전트 프레임워크입니다.
+
+## LangGraph는 어떻게 작동하나요? [[how-does-langgraph-work]]
+
+`LangGraph`는 어플리케이션의 흐름을 정의하기 위해 방향성 그래프 구조를 사용합니다:
+
+- **노드(Node)**는 각 처리 단계를 나타냅니다(LLM 호출, 도구 사용, 의사결정 등).
+- **엣지(Edge)**는 단계 간 가능한 전환을 정의합니다.
+- **상태(State)**는 사용자가 정의하고 유지하며 실행 중 노드 간에 전달됩니다. 다음에 어떤 노드를 실행할지 결정할 때, 현재 상태가 기준입니다.
+
+이러한 기본 구성 요소들은 다음 장에서 더 자세히 살펴보겠습니다!
+
+## 일반 파이썬과 어떻게 다른가요? 왜 LangGraph가 필요한가요? [[how-is-it-different-from-regular-python-why-do-i-need-langgraph]]
+
+"그냥 일반 파이썬 문법으로 if-else 문 쓰면 되지 않나요?"라고 궁금해할 수 있습니다.
+
+기술적으로는 가능하지만, LangGraph는 복잡한 시스템 구축을 위해 일반 파이썬보다 **여러가지 장점**을 제공합니다. LangGraph 없이도 동일한 어플리케이션을 구축할 수 있지만, LangGraph는 더 쉽게 개발할 수 있는 도구와 추상화를 제공합니다.
+
+예: 상태 관리, 시각화, 로깅(트레이스), 내장형 사용자 개입 처리 기능 등.
diff --git a/units/ko/unit2/llama-index/README.md b/units/ko/unit2/llama-index/README.md
new file mode 100644
index 00000000..b28ffd70
--- /dev/null
+++ b/units/ko/unit2/llama-index/README.md
@@ -0,0 +1,15 @@
+# 목차
+
+이 LlamaIndex 프레임 개요는 강의 2단원의 일부입니다. hf.co/learn에서 LlamaIndex에 대한 2단원에 접근할 수 있습니다 👉 <a href="https://hf.co/learn/agents-course/unit2/llama-index/introduction">여기</a>
+
+| 제목 | 설명 |
+| --- | --- |
+| [소개](introduction.mdx) | LlamaIndex 소개 |
+| [LlamaHub](llama-hub.mdx) | LlamaHub: 통합, 에이전트, 툴의 레지스트리 |
+| [구성 요소](components.mdx) | 구성 요소: 워크플로우의 빌딩 블록 |
+| [툴](tools.mdx) | 툴: LlamaIndex에서 툴을 구축하는 방법 |
+| [퀴즈 1](quiz1.mdx) | 퀴즈 1 |
+| [에이전트](agents.mdx) | 에이전트: LlamaIndex에서 에이전트를 구축하는 방법 |
+| [워크플로우](workflows.mdx) | 워크플로우: 순서대로 실행되는 구성 요소로 만들어진 단계, 이벤트의 시퀀스 |
+| [퀴즈 2](quiz2.mdx) | 퀴즈 2 |
+| [결론](conclusion.mdx) | 결론 |
diff --git a/units/ko/unit2/llama-index/agents.mdx b/units/ko/unit2/llama-index/agents.mdx
new file mode 100644
index 00000000..40e54a00
--- /dev/null
+++ b/units/ko/unit2/llama-index/agents.mdx
@@ -0,0 +1,160 @@
+# LlamaIndex에서 에이전트 사용하기
+
+이전에 나왔던 도움이 되는 집사 에이전트 알프레드를 기억하시나요? 이제 그가 업그레이드를 받을 차례입니다!
+이제 LlamaIndex에서 사용할 수 있는 툴들을 이해했으니, 알프레드에게 더 나은 서비스를 제공할 수 있는 새로운 기능들을 부여할 수 있습니다.
+
+하지만 계속하기 전에, 알프레드 같은 에이전트가 어떻게 작동하는지 다시 한번 상기해봅시다.
+1단원에서 우리는 다음을 배웠습니다:
+
+> 에이전트는 사용자가 정의한 목표를 달성하기 위해 AI 모델을 활용하여 환경과 상호작용하는 시스템입니다. 작업을 수행하기 위해 추론, 계획, 액션 실행(종종 외부 툴을 통해)을 결합합니다.
+
+LlamaIndex는 **세 가지 주요 유형의 추론 에이전트**를 지원합니다:
+
+![에이전트](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/llama-index/agents.png)
+
+1. `Function Calling Agents` - 특정 함수를 호출할 수 있는 AI 모델과 함께 작동합니다.
+2. `ReAct Agents` - 채팅이나 텍스트 엔드포인트를 수행하는 모든 AI와 함께 작동할 수 있으며, 복잡한 추론 작업을 처리합니다.
+3. `Advanced Custom Agents` - 더 복잡한 작업과 워크플로우를 처리하기 위해 더 복잡한 방법을 사용합니다.
+
+<Tip>고급 에이전트에 대한 더 많은 정보는 <a href="https://github.com/run-llama/llama_index/blob/main/llama-index-core/llama_index/core/agent/workflow/base_agent.py">BaseWorkflowAgent</a>에서 찾을 수 있습니다.</Tip>
+
+## 에이전트 초기화
+
+<Tip>
+<a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/llama-index/agents.ipynb" target="_blank">이 노트북</a>을 따라가며 Google Colab에서 코드를 실행해볼 수 있습니다.
+</Tip>
+
+에이전트를 만들기 위해, 먼저 **기능을 정의하는 함수/툴 세트**를 제공합니다.
+몇 가지 기본 툴로 에이전트를 만드는 방법을 살펴보겠습니다. 현재로서는 에이전트가 자동으로 함수 호출 API(사용 가능한 경우) 또는 표준 ReAct 에이전트 루프를 사용합니다.
+
+툴/함수 API를 지원하는 LLM들은 비교적 최신이지만, 특정 프롬프팅을 피하고 제공된 스키마를 기반으로 LLM이 툴 호출을 생성할 수 있게 하여 툴을 호출하는 강력한 방법을 제공합니다.
+
+ReAct 에이전트는 또한 복잡한 추론 작업에 능숙하며, 채팅이나 텍스트 완성 기능이 있는 모든 LLM과 함께 작동할 수 있습니다. 더 상세하며, 수행하는 특정 액션의 추론 과정을 보여줍니다.
+
+```python
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+from llama_index.core.agent.workflow import AgentWorkflow
+from llama_index.core.tools import FunctionTool
+
+# 샘플 툴 정의 -- 타입 어노테이션, 함수 이름, 독스트링이 모두 파싱된 스키마에 포함됩니다!
+def multiply(a: int, b: int) -> int:
+    """두 정수를 곱하고 결과 정수를 반환합니다"""
+    return a * b
+
+# llm 초기화
+llm = HuggingFaceInferenceAPI(model_name="Qwen/Qwen2.5-Coder-32B-Instruct")
+
+# 에이전트 초기화
+agent = AgentWorkflow.from_tools_or_functions(
+    [FunctionTool.from_defaults(multiply)],
+    llm=llm
+)
+```
+
+**에이전트는 기본적으로 상태가 없으며**, 과거 상호작용을 기억하는 것은 `Context` 객체를 사용하여 선택사항입니다.
+이는 여러 메시지에 걸쳐 맥락을 유지하는 챗봇이나 시간이 지남에 따라 진행 상황을 추적해야 하는 작업 관리자처럼 이전 상호작용을 기억해야 하는 에이전트를 사용하고 싶을 때 유용할 수 있습니다.
+
+```python
+# 상태 없음
+response = await agent.run("2 곱하기 2는 무엇인가요?")
+
+# 상태 기억
+from llama_index.core.workflow import Context
+
+ctx = Context(agent)
+
+response = await agent.run("내 이름은 Bob입니다.", ctx=ctx)
+response = await agent.run("내 이름이 뭐였지?", ctx=ctx)
+```
+
+`LlamaIndex`의 에이전트들이 Python의 `await` 연산자를 사용하기 때문에 비동기라는 것을 알 수 있습니다. Python의 비동기 코드가 처음이거나 복습이 필요하다면, [훌륭한 비동기 가이드](https://docs.llamaindex.ai/en/stable/getting_started/async_python/)가 있습니다.
+
+이제 기본을 마스터했으니, 에이전트에서 더 복잡한 툴을 사용하는 방법을 살펴보겠습니다.
+
+## QueryEngineTools로 RAG 에이전트 만들기
+
+**에이전트 RAG는 에이전트를 사용하여 데이터에 대한 질문에 답하는 강력한 방법입니다.** 알프레드가 질문에 답하는 데 도움이 되도록 다양한 툴을 전달할 수 있습니다.
+하지만 문서 위에서 자동으로 질문에 답하는 대신, 알프레드는 질문에 답하기 위해 다른 툴이나 흐름을 사용할지 결정할 수 있습니다.
+
+![에이전트 RAG](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/llama-index/agentic-rag.png)
+
+에이전트를 위해 **`QueryEngine`을 툴로 래핑**하는 것은 쉽습니다.
+이렇게 할 때, **이름과 설명을 정의**해야 합니다. LLM은 이 정보를 사용하여 툴을 올바르게 사용합니다.
+[구성 요소 섹션](components)에서 만든 `QueryEngine`을 사용하여 `QueryEngineTool`을 로드하는 방법을 살펴보겠습니다.
+
+```python
+from llama_index.core.tools import QueryEngineTool
+
+query_engine = index.as_query_engine(llm=llm, similarity_top_k=3) # LlamaIndex의 구성 요소 섹션에서 보여진 대로
+
+query_engine_tool = QueryEngineTool.from_defaults(
+    query_engine=query_engine,
+    name="name",
+    description="a specific description",
+    return_direct=False,
+)
+query_engine_agent = AgentWorkflow.from_tools_or_functions(
+    [query_engine_tool],
+    llm=llm,
+    system_prompt="You are a helpful assistant that has access to a database containing persona descriptions. "
+)
+```
+
+## 다중 에이전트 시스템 만들기
+
+`AgentWorkflow` 클래스는 다중 에이전트 시스템도 직접 지원합니다. 각 에이전트에 이름과 설명을 부여함으로써, 시스템은 단일 활성 발화자를 유지하며, 각 에이전트는 다른 에이전트에게 작업을 넘길 수 있는 능력을 가집니다.
+
+각 에이전트의 범위를 좁힘으로써, 사용자 메시지에 응답할 때 일반적인 정확도를 높이는 데 도움이 될 수 있습니다.
+
+**LlamaIndex의 에이전트들은 더 복잡하고 사용자 정의 시나리오를 위해 다른 에이전트의 툴로도 직접 사용될 수 있습니다.**
+
+```python
+from llama_index.core.agent.workflow import (
+    AgentWorkflow,
+    FunctionAgent,
+    ReActAgent,
+)
+
+# 몇 가지 툴 정의
+def add(a: int, b: int) -> int:
+    """두 숫자를 더합니다."""
+    return a + b
+
+
+def subtract(a: int, b: int) -> int:
+    """두 숫자를 뺍니다."""
+    return a - b
+
+
+# 에이전트 설정 생성
+# 참고: 여기서 FunctionAgent 또는 ReActAgent를 사용할 수 있습니다.
+# FunctionAgent는 함수 호출 API가 있는 LLM용입니다.
+# ReActAgent는 모든 LLM용입니다.
+calculator_agent = ReActAgent(
+    name="calculator",
+    description="기본 산술 연산을 수행합니다",
+    system_prompt="당신은 계산기 어시스턴트입니다. 모든 수학 연산에 툴을 사용하세요.",
+    tools=[add, subtract],
+    llm=llm,
+)
+
+query_agent = ReActAgent(
+    name="info_lookup",
+    description="XYZ에 대한 정보를 찾습니다",
+    system_prompt="XYZ에 대한 정보를 답하기 위해 RAG 시스템을 쿼리하는 툴을 사용하세요",
+    tools=[query_engine_tool],
+    llm=llm
+)
+
+# 워크플로우 생성 및 실행
+agent = AgentWorkflow(
+    agents=[calculator_agent, query_agent], root_agent="calculator"
+)
+
+# 시스템 실행
+response = await agent.run(user_msg="5와 3을 더할 수 있나요?")
+```
+
+<Tip>아직 충분히 배우지 못했나요? <a href="https://docs.llamaindex.ai/en/stable/examples/agent/agent_workflow_basic/">AgentWorkflow 기본 소개</a> 또는 <a href="https://docs.llamaindex.ai/en/stable/understanding/agent/">에이전트 학습 가이드</a>에서 LlamaIndex의 에이전트와 툴에 대해 더 많은 것을 발견할 수 있으며, 스트리밍, 맥락 직렬화, 사람 개입에 대해 더 읽을 수 있습니다!</Tip>
+
+이제 LlamaIndex에서 에이전트와 툴의 기본을 이해했으니, LlamaIndex를 사용하여 **구성 가능하고 관리 가능한 워크플로우를 만드는** 방법을 살펴보겠습니다!
diff --git a/units/ko/unit2/llama-index/components.mdx b/units/ko/unit2/llama-index/components.mdx
new file mode 100644
index 00000000..1f7a4d83
--- /dev/null
+++ b/units/ko/unit2/llama-index/components.mdx
@@ -0,0 +1,241 @@
+# LlamaIndex의 구성 요소란 무엇인가요?
+
+1단원에서 나왔던 도움이 되는 집사 에이전트 알프레드를 기억하시나요?
+효과적으로 우리를 도우려면, 알프레드는 우리의 요청을 이해하고 **작업을 완료하는 데 도움이 되는 관련 정보를 준비하고, 찾고, 사용**할 수 있어야 합니다.
+이것이 LlamaIndex의 구성 요소가 들어오는 곳입니다.
+
+LlamaIndex에는 많은 구성 요소가 있지만, **우리는 특별히 `QueryEngine` 구성 요소에 집중할 것입니다.**
+왜냐고요? 에이전트의 검색 증강 생성(RAG) 툴로 사용할 수 있기 때문입니다.
+
+그럼 RAG란 무엇일까요? LLM은 일반적인 지식을 배우기 위해 엄청난 양의 데이터로 훈련됩니다.
+하지만 관련 있고 최신 데이터로 훈련되지 않았을 수 있습니다.
+RAG는 데이터에서 관련 정보를 찾고 검색하여 LLM에게 제공함으로써 이 문제를 해결합니다.
+
+![RAG](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/llama-index/rag.png)
+
+이제 알프레드가 어떻게 작동하는지 생각해보세요:
+
+1. 알프레드에게 저녁 파티 계획을 도와달라고 요청합니다
+2. 알프레드는 캘린더, 식이 선호도, 과거 성공한 메뉴를 확인해야 합니다
+3. `QueryEngine`이 알프레드가 이 정보를 찾고 저녁 파티 계획에 사용하도록 도와줍니다
+
+이것이 `QueryEngine`을 LlamaIndex에서 **에이전트 RAG 워크플로우를 구축하기 위한 핵심 구성 요소**로 만듭니다.
+알프레드가 도움이 되기 위해 가정 정보를 검색해야 하는 것처럼, 모든 에이전트는 관련 데이터를 찾고 이해할 수 있는 방법이 필요합니다.
+`QueryEngine`은 정확히 이 기능을 제공합니다.
+
+이제 구성 요소에 대해 조금 더 깊이 들어가서 **구성 요소를 결합하여 RAG 파이프라인을 만드는** 방법을 살펴보겠습니다.
+
+## 구성 요소를 사용하여 RAG 파이프라인 만들기
+
+<Tip>
+<a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/llama-index/components.ipynb" target="_blank">이 노트북</a>을 따라가며 Google Colab에서 코드를 실행해볼 수 있습니다.
+</Tip>
+
+RAG 내에는 5가지 주요 단계가 있으며, 이는 구축하는 대부분의 더 큰 어플리케이션의 일부가 됩니다:
+
+1. **로딩**: 데이터가 있는 곳(텍스트 파일, PDF, 다른 웹사이트, 데이터베이스, API)에서 워크플로우로 데이터를 가져오는 것을 의미합니다. LlamaHub는 선택할 수 있는 수백 개의 통합을 제공합니다.
+2. **인덱싱**: 데이터를 쿼리할 수 있는 데이터 구조를 만드는 것을 의미합니다. LLM의 경우, 이는 거의 항상 벡터 임베딩을 만드는 것을 의미합니다. 이는 데이터 의미의 수치적 표현입니다. 인덱싱은 속성을 기반으로 맥락적으로 관련된 데이터를 정확하게 찾기 쉽게 만드는 수많은 다른 메타데이터 전략을 의미할 수도 있습니다.
+3. **저장**: 데이터가 인덱싱되면 다시 인덱싱할 필요가 없도록 인덱스와 다른 메타데이터를 저장하고 싶을 것입니다.
+4. **쿼리**: 주어진 인덱싱 전략에 대해 하위 쿼리, 다단계 쿼리, 하이브리드 전략을 포함하여 LLM과 LlamaIndex 데이터 구조를 사용하여 쿼리할 수 있는 많은 방법이 있습니다.
+5. **평가**: 모든 흐름에서 중요한 단계는 다른 전략에 비해 얼마나 효과적인지, 또는 변경사항을 만들 때 확인하는 것입니다. 평가는 쿼리에 대한 응답이 얼마나 정확하고, 신뢰할 수 있고, 빠른지에 대한 객관적인 측정을 제공합니다.
+
+다음으로, 구성 요소를 사용하여 이러한 단계들을 재현하는 방법을 살펴보겠습니다.
+
+### 문서 로딩 및 임베딩
+
+앞서 언급했듯이, LlamaIndex는 자체 데이터 위에서 작동할 수 있지만, **데이터에 접근하기 전에 로드해야 합니다.**
+LlamaIndex에 데이터를 로드하는 세 가지 주요 방법이 있습니다:
+
+1. `SimpleDirectoryReader`: 로컬 디렉토리에서 다양한 파일 유형을 위한 내장 로더입니다.
+2. `LlamaParse`: PDF 파싱을 위한 LlamaIndex의 공식 툴인 LlamaParse로, 관리형 API로 사용 가능합니다.
+3. `LlamaHub`: 모든 소스에서 데이터를 수집하기 위한 수백 개의 데이터 로딩 라이브러리 레지스트리입니다.
+
+<Tip>더 복잡한 데이터 소스를 위해 <a href="https://docs.llamaindex.ai/en/stable/module_guides/loading/connector/">LlamaHub</a> 로더와 <a href="https://github.com/run-llama/llama_cloud_services/blob/main/parse.md">LlamaParse</a> 파서에 익숙해지세요.</Tip>
+
+**데이터를 로드하는 가장 간단한 방법은 `SimpleDirectoryReader`를 사용하는 것입니다.**
+이 다재다능한 구성 요소는 폴더에서 다양한 파일 유형을 로드하고 LlamaIndex가 작업할 수 있는 `Document` 객체로 변환할 수 있습니다.
+`SimpleDirectoryReader`를 사용하여 폴더에서 데이터를 로드하는 방법을 살펴보겠습니다.
+
+```python
+from llama_index.core import SimpleDirectoryReader
+
+reader = SimpleDirectoryReader(input_dir="path/to/directory")
+documents = reader.load_data()
+```
+
+문서를 로드한 후, `Node` 객체라는 더 작은 조각들로 나누어야 합니다.
+`Node`는 AI가 작업하기 더 쉬운 원본 문서의 텍스트 청크일 뿐이며, 여전히 원본 `Document` 객체에 대한 참조를 가지고 있습니다.
+
+`IngestionPipeline`은 두 가지 주요 변환을 통해 이러한 노드를 만드는 데 도움이 됩니다.
+1. `SentenceSplitter`는 자연스러운 문장 경계에서 문서를 분할하여 관리 가능한 청크로 나눕니다.
+2. `HuggingFaceEmbedding`은 각 청크를 수치적 임베딩으로 변환합니다 - AI가 효율적으로 처리할 수 있는 방식으로 의미적 의미를 포착하는 벡터 표현입니다.
+
+이 과정은 검색과 분석에 더 유용한 방식으로 문서를 구성하는 데 도움이 됩니다.
+
+```python
+from llama_index.core import Document
+from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+from llama_index.core.node_parser import SentenceSplitter
+from llama_index.core.ingestion import IngestionPipeline
+
+# 변환과 함께 파이프라인 생성
+pipeline = IngestionPipeline(
+    transformations=[
+        SentenceSplitter(chunk_overlap=0),
+        HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5"),
+    ]
+)
+
+nodes = await pipeline.arun(documents=[Document.example()])
+```
+
+### 문서 저장 및 인덱싱
+
+`Node` 객체를 만든 후, 검색 가능하게 만들기 위해 인덱싱해야 하지만, 그 전에 데이터를 저장할 곳이 필요합니다.
+
+수집 파이프라인을 사용하고 있으므로, 파이프라인에 벡터 스토어를 직접 연결하여 채울 수 있습니다.
+이 경우, 문서를 저장하기 위해 `Chroma`를 사용할 것입니다.
+
+<details>
+<summary>ChromaDB 설치</summary>
+
+<a href="./llama-hub">LlamaHub 섹션</a>에서 소개된 대로, 다음 명령어로 ChromaDB 벡터 스토어를 설치할 수 있습니다:
+
+```bash
+pip install llama-index-vector-stores-chroma
+```
+</details>
+
+```python
+import chromadb
+from llama_index.vector_stores.chroma import ChromaVectorStore
+
+db = chromadb.PersistentClient(path="./alfred_chroma_db")
+chroma_collection = db.get_or_create_collection("alfred")
+vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
+
+pipeline = IngestionPipeline(
+    transformations=[
+        SentenceSplitter(chunk_size=25, chunk_overlap=0),
+        HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5"),
+    ],
+    vector_store=vector_store,
+)
+```
+
+<Tip>다양한 벡터 스토어에 대한 개요는 <a href="https://docs.llamaindex.ai/en/stable/module_guides/storing/vector_stores/">LlamaIndex 문서</a>에서 찾을 수 있습니다.</Tip>
+
+이것이 벡터 임베딩이 들어오는 곳입니다 - 쿼리와 노드를 같은 벡터 공간에 임베딩함으로써 관련 매치를 찾을 수 있습니다.
+`VectorStoreIndex`는 일관성을 보장하기 위해 수집 중에 사용한 것과 같은 임베딩 모델을 사용하여 이를 처리합니다.
+
+벡터 스토어와 임베딩에서 이 인덱스를 만드는 방법을 살펴보겠습니다:
+
+```python
+from llama_index.core import VectorStoreIndex
+from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+
+embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5")
+index = VectorStoreIndex.from_vector_store(vector_store, embed_model=embed_model)
+```
+
+모든 정보는 `ChromaVectorStore` 객체와 전달된 디렉토리 경로 내에서 자동으로 지속됩니다.
+
+훌륭합니다! 이제 인덱스를 쉽게 저장하고 로드할 수 있으니, 다양한 방법으로 쿼리하는 방법을 탐구해보겠습니다.
+
+### 프롬프트와 LLM으로 VectorStoreIndex 쿼리하기
+
+인덱스를 쿼리하기 전에, 쿼리 인터페이스로 변환해야 합니다. 가장 일반적인 변환 옵션은 다음과 같습니다:
+
+- `as_retriever`: 기본 문서 검색용으로, 유사도 점수가 있는 `NodeWithScore` 객체 리스트를 반환합니다
+- `as_query_engine`: 단일 질문-답변 상호작용용으로, 작성된 응답을 반환합니다
+- `as_chat_engine`: 여러 메시지에 걸쳐 메모리를 유지하는 대화형 상호작용용으로, 채팅 기록과 인덱싱된 맥락을 사용하여 작성된 응답을 반환합니다
+
+에이전트와 같은 상호작용에 더 일반적이므로 쿼리 엔진에 집중하겠습니다.
+응답에 사용할 LLM도 쿼리 엔진에 전달합니다.
+
+```python
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+
+llm = HuggingFaceInferenceAPI(model_name="Qwen/Qwen2.5-Coder-32B-Instruct")
+query_engine = index.as_query_engine(
+    llm=llm,
+    response_mode="tree_summarize",
+)
+query_engine.query("인생의 의미는 무엇인가요?")
+# 인생의 의미는 42입니다
+```
+
+### 응답 처리
+
+내부적으로, 쿼리 엔진은 질문에 답하기 위해 LLM만 사용하는 것이 아니라 응답을 처리하기 위한 전략으로 `ResponseSynthesizer`도 사용합니다.
+다시 한번, 이것은 완전히 사용자 정의 가능하지만 즉시 잘 작동하는 세 가지 주요 전략이 있습니다:
+
+- `refine`: 검색된 각 텍스트 청크를 순차적으로 거쳐 답변을 생성하고 개선합니다. 이는 Node/검색된 청크당 별도의 LLM 호출을 만듭니다.
+- `compact` (기본값): 개선과 유사하지만 미리 청크를 연결하여 더 적은 LLM 호출을 만듭니다.
+- `tree_summarize`: 검색된 각 텍스트 청크를 거쳐 답변의 트리 구조를 만들어 상세한 답변을 생성합니다.
+
+<Tip><a href="https://docs.llamaindex.ai/en/stable/module_guides/deploying/query_engine/usage_pattern/#low-level-composition-api">저수준 구성 API</a>로 쿼리 워크플로우를 세밀하게 제어하세요. 이 API는 쿼리 프로세스의 모든 단계를 사용자 정의하고 미세 조정하여 정확한 요구사항에 맞출 수 있게 해주며, <a href="https://docs.llamaindex.ai/en/stable/module_guides/workflow/">워크플로우</a>와도 잘 맞습니다.</Tip>
+
+언어 모델이 항상 예측 가능한 방식으로 수행되지 않을 수 있으므로, 우리가 얻는 답변이 항상 정확하다고 확신할 수 없습니다. **답변의 품질을 평가**함으로써 이를 처리할 수 있습니다.
+
+### 평가 및 관찰 가능성
+
+LlamaIndex는 **응답 품질을 평가하기 위한 내장 평가 도구**를 제공합니다.
+이러한 평가자는 LLM을 활용하여 다양한 차원에서 응답을 분석합니다.
+사용 가능한 세 가지 주요 평가자를 살펴보겠습니다:
+
+- `FaithfulnessEvaluator`: 답변이 맥락에 의해 지원되는지 확인하여 답변의 신뢰성을 평가합니다.
+- `AnswerRelevancyEvaluator`: 답변이 질문과 관련이 있는지 확인하여 답변의 관련성을 평가합니다.
+- `CorrectnessEvaluator`: 답변이 정확한지 확인하여 답변의 정확성을 평가합니다.
+
+<Tip>에이전트 관찰 가능성과 평가에 대해 더 배우고 싶나요? <a href="https://huggingface.co/learn/agents-course/bonus-unit2/introduction">보너스 단원 2</a>로 여정을 계속하세요.</Tip>
+
+```python
+from llama_index.core.evaluation import FaithfulnessEvaluator
+
+query_engine = # 이전 섹션에서
+llm = # 이전 섹션에서
+
+# 인덱스 쿼리
+evaluator = FaithfulnessEvaluator(llm=llm)
+response = query_engine.query(
+    "미국 혁명에서 뉴욕시에서 어떤 전투가 일어났나요?"
+)
+eval_result = evaluator.evaluate_response(response=response)
+eval_result.passing
+```
+
+직접적인 평가 없이도 **관찰 가능성을 통해 시스템이 어떻게 수행되고 있는지에 대한 통찰을 얻을 수 있습니다.**
+이는 더 복잡한 워크플로우를 구축하고 각 구성 요소가 어떻게 수행되고 있는지 이해하고 싶을 때 특히 유용합니다.
+
+<details>
+<summary>LlamaTrace 설치</summary>
+
+<a href="./llama-hub">LlamaHub 섹션</a>에서 소개된 대로, 다음 명령어로 Arize Phoenix의 LlamaTrace 콜백을 설치할 수 있습니다:
+
+```bash
+pip install -U llama-index-callbacks-arize-phoenix
+```
+
+또한 LlamaTrace API 키를 `PHOENIX_API_KEY` 환경 변수로 설정해야 합니다. 다음을 통해 얻을 수 있습니다:
+- [LlamaTrace](https://llamatrace.com/login)에서 계정 생성
+- 계정 설정에서 API 키 생성
+- 아래 코드에서 추적을 활성화하기 위해 API 키 사용
+
+</details>
+
+```python
+import llama_index
+import os
+
+PHOENIX_API_KEY = "<PHOENIX_API_KEY>"
+os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"api_key={PHOENIX_API_KEY}"
+llama_index.core.set_global_handler(
+    "arize_phoenix",
+    endpoint="https://llamatrace.com/v1/traces"
+)
+```
+
+<Tip>구성 요소와 사용 방법에 대해 더 배우고 싶나요? <a href="https://docs.llamaindex.ai/en/stable/module_guides/">구성 요소 가이드</a> 또는 <a href="https://docs.llamaindex.ai/en/stable/understanding/rag/">RAG 가이드</a>로 여정을 계속하세요.</Tip>
+
+구성 요소를 사용하여 `QueryEngine`을 만드는 방법을 보았습니다. 이제 **`QueryEngine`을 에이전트의 툴로 사용하는** 방법을 살펴보겠습니다!
diff --git a/units/ko/unit2/llama-index/conclusion.mdx b/units/ko/unit2/llama-index/conclusion.mdx
new file mode 100644
index 00000000..c0e7f825
--- /dev/null
+++ b/units/ko/unit2/llama-index/conclusion.mdx
@@ -0,0 +1,13 @@
+# 결론
+
+2단원의 `llama-index` 모듈을 완료하신 것을 축하합니다! 🥳
+
+방금 `llama-index`의 기본을 마스터하고 자신만의 에이전트 워크플로우를 구축하는 방법을 보셨습니다!
+이제 `llama-index` 기술을 갖추셨으니, 관심 있는 작업을 해결할 검색 엔진을 만들기 시작할 수 있습니다.
+
+이 단원의 다음 모듈에서는 **LangGraph로 에이전트를 구축하는 방법**을 배우게 됩니다.
+
+마지막으로, **강의에 대한 여러분의 생각과 개선 방법**을 듣고 싶습니다.
+피드백이 있으시면 👉 [이 양식을 작성해주세요](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog)
+
+### 계속 배우고, 멋지게 유지하세요! 🤗
diff --git a/units/ko/unit2/llama-index/introduction.mdx b/units/ko/unit2/llama-index/introduction.mdx
new file mode 100644
index 00000000..c0d923e2
--- /dev/null
+++ b/units/ko/unit2/llama-index/introduction.mdx
@@ -0,0 +1,29 @@
+# LlamaIndex 소개
+
+[LlamaIndex](https://www.llamaindex.ai/) 툴킷을 사용하여 LLM 기반 에이전트를 구축하는 방법을 배우는 이 모듈에 오신 것을 환영합니다.
+
+LlamaIndex는 **인덱스와 워크플로우를 사용하여 데이터 위에서 LLM 기반 에이전트를 만드는 완전한 툴킷**입니다. 이 강의에서는 LlamaIndex에서 에이전트를 구축하는 데 도움이 되는 세 가지 주요 부분에 집중할 것입니다: **구성 요소**, **에이전트와 툴**, 그리고 **워크플로우**입니다.
+
+![LlamaIndex](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/llama-index/thumbnail.png)
+
+LlamaIndex의 이러한 핵심 부분들과 에이전트에 어떻게 도움이 되는지 살펴보겠습니다:
+
+- **구성 요소**: LlamaIndex에서 사용하는 기본 빌딩 블록입니다. 프롬프트, 모델, 데이터베이스 등이 포함됩니다. 구성 요소는 종종 LlamaIndex를 다른 툴과 라이브러리와 연결하는 데 도움이 됩니다.
+- **툴**: 검색, 계산, 외부 서비스 접근과 같은 특정 기능을 제공하는 구성 요소입니다. 에이전트가 작업을 수행할 수 있게 하는 빌딩 블록입니다.
+- **에이전트**: 툴을 사용하고 결정을 내릴 수 있는 자율 구성 요소입니다. 복잡한 목표를 달성하기 위해 툴 사용을 조정합니다.
+- **워크플로우**: 로직을 함께 처리하는 단계별 프로세스입니다. 워크플로우 또는 에이전트 워크플로우는 명시적인 에이전트 사용 없이 에이전트 행동을 구조화하는 방법입니다.
+
+## LlamaIndex를 특별하게 만드는 것은 무엇인가요?
+
+LlamaIndex가 smolagents와 같은 다른 프레임워크와 유사한 일부 작업을 수행하지만, 몇 가지 주요 이점이 있습니다:
+
+- **명확한 워크플로우 시스템**: 워크플로우는 이벤트 기반 및 비동기 우선 구문을 사용하여 에이전트가 단계별로 어떻게 결정을 내려야 하는지 분해하는 데 도움이 됩니다. 이는 로직을 명확하게 구성하고 구성하는 데 도움이 됩니다.
+- **LlamaParse를 통한 고급 문서 파싱**: LlamaParse는 LlamaIndex를 위해 특별히 만들어졌으므로 통합이 원활하지만, 유료 기능입니다.
+- **많은 즉시 사용 가능한 구성 요소**: LlamaIndex는 오랫동안 존재해왔으므로 많은 다른 프레임워크와 함께 작동합니다. 이는 LLM, 검색기, 인덱스 등과 같은 많은 테스트되고 신뢰할 수 있는 구성 요소가 있음을 의미합니다.
+- **LlamaHub**: LlamaIndex 내에서 사용할 수 있는 이러한 구성 요소, 에이전트, 툴의 수백 개 레지스트리입니다.
+
+이러한 모든 개념은 유용한 에이전트를 만들기 위해 다양한 시나리오에서 필요합니다.
+다음 섹션에서는 이러한 개념들을 각각 자세히 살펴볼 것입니다.
+개념을 마스터한 후, 우리의 학습을 사용하여 **에이전트 알프레드와 함께 적용된 사용 사례를 만들** 것입니다!
+
+LlamaIndex를 직접 다루는 것이 흥미롭지 않나요? 그럼 무엇을 기다리고 있나요? **LlamaHub를 사용하여 필요한 통합을 찾고 설치하는** 것으로 시작해봅시다! 🚀
\ No newline at end of file
diff --git a/units/ko/unit2/llama-index/llama-hub.mdx b/units/ko/unit2/llama-index/llama-hub.mdx
new file mode 100644
index 00000000..6da1486b
--- /dev/null
+++ b/units/ko/unit2/llama-index/llama-hub.mdx
@@ -0,0 +1,55 @@
+# LlamaHub 소개
+
+**LlamaHub는 LlamaIndex 내에서 사용할 수 있는 수백 개의 통합, 에이전트, 툴의 레지스트리입니다.**
+
+![LlamaHub](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/llama-index/llama-hub.png)
+
+이 강의에서 다양한 통합을 사용할 것이므로, 먼저 LlamaHub와 그것이 어떻게 우리를 도울 수 있는지 살펴보겠습니다.
+
+필요한 구성 요소의 의존성을 찾고 설치하는 방법을 살펴보겠습니다.
+
+## 설치
+
+LlamaIndex 설치 지침은 [LlamaHub](https://llamahub.ai/)에서 잘 구조화된 **개요로 제공**됩니다.
+처음에는 조금 압도적일 수 있지만, 대부분의 **설치 명령어는 일반적으로 기억하기 쉬운 형식**을 따릅니다:
+
+```bash
+pip install llama-index-{component-type}-{framework-name}
+```
+
+[Hugging Face 추론 API 통합](https://llamahub.ai/l/llms/llama-index-llms-huggingface-api?from=llms)을 사용하여 LLM과 임베딩 구성 요소의 의존성을 설치해보겠습니다.
+
+```bash
+pip install llama-index-llms-huggingface-api llama-index-embeddings-huggingface
+```
+
+## 사용법
+
+설치되면 사용 패턴을 볼 수 있습니다. 가져오기 경로가 설치 명령어를 따르는 것을 알 수 있을 것입니다!
+아래에서 **LLM 구성 요소를 위한 Hugging Face 추론 API 사용**의 예를 볼 수 있습니다.
+
+```python
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+import os
+from dotenv import load_dotenv
+
+# .env 파일 로드
+load_dotenv()
+
+# 환경 변수에서 HF_TOKEN 검색
+hf_token = os.getenv("HF_TOKEN")
+
+llm = HuggingFaceInferenceAPI(
+    model_name="Qwen/Qwen2.5-Coder-32B-Instruct",
+    temperature=0.7,
+    max_tokens=100,
+    token=hf_token,
+)
+
+response = llm.complete("안녕하세요, 어떻게 지내시나요?")
+print(response)
+# 잘 지내고 있습니다, 오늘 어떻게 도와드릴까요?
+```
+
+훌륭합니다, 이제 필요한 구성 요소의 통합을 찾고, 설치하고, 사용하는 방법을 알게 되었습니다.
+**구성 요소에 대해 더 깊이 들어가서** 우리만의 에이전트를 구축하는 데 어떻게 사용할 수 있는지 살펴보겠습니다.
diff --git a/units/ko/unit2/llama-index/quiz1.mdx b/units/ko/unit2/llama-index/quiz1.mdx
new file mode 100644
index 00000000..7e542df7
--- /dev/null
+++ b/units/ko/unit2/llama-index/quiz1.mdx
@@ -0,0 +1,117 @@
+# 미니 퀴즈 (채점되지 않음) [[quiz1]]
+
+지금까지 LlamaIndex에서 사용되는 주요 구성 요소와 툴에 대해 논의했습니다.
+**자신을 테스트하는 것**이 학습하는 가장 좋은 방법이고 [능력의 착각을 피하는](https://www.coursera.org/lecture/learning-how-to-learn/illusions-of-competence-BuFzf) 방법이므로 짧은 퀴즈를 만들어보겠습니다.
+이것은 **지식을 강화해야 할 부분을 찾는** 데 도움이 될 것입니다.
+
+이것은 선택사항 퀴즈이며 채점되지 않습니다.
+
+### Q1: QueryEngine이란 무엇인가요?
+다음 중 QueryEngine 구성 요소를 가장 잘 설명하는 것은 무엇인가요?
+
+<Question
+choices={[
+{
+text: "검색 기능이 없는 정적 텍스트만 처리하는 시스템입니다.",
+explain: "QueryEngine은 관련 정보를 검색하고 처리할 수 있어야 합니다.",
+},
+{
+text: "RAG 프로세스의 일부로 관련 정보를 찾고 검색하는 구성 요소입니다.",
+explain: "이것이 QueryEngine 구성 요소의 핵심 목적을 포착합니다.",
+correct: true
+},
+{
+text: "검색 기능 없이 벡터 임베딩만 저장하는 툴입니다.",
+explain: "QueryEngine은 임베딩을 저장하는 것 이상을 수행합니다 - 적극적으로 검색하고 정보를 검색합니다.",
+},
+{
+text: "응답 품질만 평가하는 구성 요소입니다.",
+explain: "평가는 QueryEngine의 주요 검색 목적과는 별개입니다.",
+}
+]}
+/>
+
+---
+
+### Q2: FunctionTools의 목적은 무엇인가요?
+에이전트에게 FunctionTools가 중요한 이유는 무엇인가요?
+
+<Question
+choices={[
+{
+text: "대량의 데이터 저장을 처리하기 위해.",
+explain: "FunctionTools는 주로 데이터 저장용이 아닙니다.",
+},
+{
+text: "Python 함수를 에이전트가 사용할 수 있는 툴로 변환하기 위해.",
+explain: "FunctionTools는 Python 함수를 래핑하여 에이전트가 접근할 수 있게 만듭니다.",
+correct: true
+},
+{
+text: "에이전트가 무작위 함수 정의를 만들 수 있게 하기 위해.",
+explain: "FunctionTools는 함수를 에이전트가 사용할 수 있게 만드는 특정 목적을 제공합니다.",
+},
+{
+text: "텍스트 데이터만 처리하기 위해.",
+explain: "FunctionTools는 텍스트 처리뿐만 아니라 다양한 유형의 함수와 함께 작동할 수 있습니다.",
+}
+]}
+/>
+
+---
+
+### Q3: LlamaIndex의 Toolspecs란 무엇인가요?
+Toolspecs의 주요 목적은 무엇인가요?
+
+<Question
+choices={[
+{
+text: "기능을 추가하지 않는 중복 구성 요소입니다.",
+explain: "Toolspecs는 LlamaIndex 생태계에서 중요한 목적을 제공합니다.",
+},
+{
+text: "에이전트 기능을 확장하는 커뮤니티에서 만든 툴 세트입니다.",
+explain: "Toolspecs는 커뮤니티가 툴을 공유하고 재사용할 수 있게 합니다.",
+correct: true
+},
+{
+text: "메모리 관리만을 위해 사용됩니다.",
+explain: "Toolspecs는 툴 제공에 관한 것이지 메모리 관리가 아닙니다.",
+},
+{
+text: "텍스트 처리와만 작동합니다.",
+explain: "Toolspecs는 텍스트 처리뿐만 아니라 다양한 유형의 툴을 포함할 수 있습니다.",
+}
+]}
+/>
+
+---
+
+### Q4: 툴을 만들기 위해 필요한 것은 무엇인가요?
+툴을 만들 때 포함해야 하는 정보는 무엇인가요?
+
+<Question
+choices={[
+{
+text: "함수, 이름, 설명이 정의되어야 합니다.",
+explain: "이 모든 것이 툴을 구성하지만, 이름과 설명은 함수와 독스트링에서 파싱될 수 있습니다.",
+},
+{
+text: "이름만 필요합니다.",
+explain: "적절한 툴 문서화를 위해 함수와 설명/독스트링도 필요합니다.",
+},
+{
+text: "설명만 필요합니다.",
+explain: "에이전트가 툴을 선택할 때 실행할 코드가 있도록 함수가 필요합니다",
+},
+{
+text: "함수만 필요합니다.",
+explain: "이름과 설명은 제공된 함수의 이름과 독스트링으로 기본 설정됩니다",
+correct: true
+}
+]}
+/>
+
+---
+
+이 퀴즈를 완료하신 것을 축하합니다! 🥳 일부 요소를 놓쳤다면, 지식을 강화하기 위해 챕터를 다시 읽어보세요. 통과하셨다면, 이러한 구성 요소로 더 깊이 구축할 준비가 되었습니다!
diff --git a/units/ko/unit2/llama-index/quiz2.mdx b/units/ko/unit2/llama-index/quiz2.mdx
new file mode 100644
index 00000000..373ae1eb
--- /dev/null
+++ b/units/ko/unit2/llama-index/quiz2.mdx
@@ -0,0 +1,112 @@
+# 셀프 체크 (채점되지 않음) [[quiz2]]
+
+뭐?! 또 다른 퀴즈? 알겠습니다, 알겠습니다... 😅 하지만 이 짧은, 채점되지 않는 퀴즈는 **방금 배운 핵심 개념을 강화하는 데 도움이** 되기 위해 여기 있습니다.
+
+이 퀴즈는 효과적인 AI 에이전트를 구축하기 위한 필수 구성 요소인 에이전트 워크플로우와 상호작용을 다룹니다.
+
+### Q1: LlamaIndex에서 AgentWorkflow의 목적은 무엇인가요?
+
+<Question
+choices={[
+{
+text: "툴과 함께 하나 이상의 에이전트를 실행하기 위해",
+explain: "네, AgentWorkflow는 하나 이상의 에이전트로 시스템을 빠르게 만드는 주요 방법입니다.",
+correct: true
+},
+{
+text: "메모리 없이 데이터를 쿼리할 수 있는 단일 에이전트를 만들기 위해",
+explain: "아니요, AgentWorkflow는 그보다 더 능력이 있습니다. QueryEngine은 데이터에 대한 간단한 쿼리용입니다.",
+},
+{
+text: "에이전트를 위한 툴을 자동으로 구축하기 위해",
+explain: "AgentWorkflow는 툴을 구축하지 않습니다. 그것은 개발자의 작업입니다.",
+},
+{
+text: "에이전트 메모리와 상태를 관리하기 위해",
+explain: "메모리와 상태 관리는 AgentWorkflow의 주요 목적이 아닙니다.",
+}
+]}
+/>
+
+---
+
+### Q2: 워크플로우의 상태를 추적하는 데 사용되는 객체는 무엇인가요?
+
+<Question
+choices={[
+{
+text: "State",
+explain: "State는 워크플로우 상태 관리에 올바른 객체가 아닙니다.",
+},
+{
+text: "Context",
+explain: "Context는 워크플로우 상태를 추적하는 데 사용되는 올바른 객체입니다.",
+correct: true
+},
+{
+text: "WorkflowState",
+explain: "WorkflowState는 올바른 객체가 아닙니다.",
+},
+{
+text: "Management",
+explain: "Management는 워크플로우 상태에 대한 유효한 객체가 아닙니다.",
+}
+]}
+/>
+
+---
+
+### Q3: 에이전트가 이전 상호작용을 기억하게 하려면 어떤 메서드를 사용해야 하나요?
+
+<Question
+choices={[
+{
+text: "run(query_str)",
+explain: ".run(query_str)는 대화 기록을 유지하지 않습니다.",
+},
+{
+text: "chat(query_str, ctx=ctx)",
+explain: "chat()은 워크플로우에서 유효한 메서드가 아닙니다.",
+},
+{
+text: "interact(query_str)",
+explain: "interact()은 에이전트 상호작용에 대한 유효한 메서드가 아닙니다.",
+},
+{
+text: "run(query_str, ctx=ctx)",
+explain: "맥락을 전달하고 유지함으로써 상태를 유지할 수 있습니다!",
+correct: true
+}
+]}
+/>
+
+---
+
+### Q4: 에이전트 RAG의 주요 특징은 무엇인가요?
+
+<Question
+choices={[
+{
+text: "RAG 워크플로우에서 질문에 답하기 위해 문서 기반 툴만 사용할 수 있습니다",
+explain: "에이전트 RAG는 문서 기반 툴을 포함한 다양한 툴을 사용할 수 있습니다.",
+},
+{
+text: "챗봇처럼 툴 없이 자동으로 질문에 답합니다",
+explain: "에이전트 RAG는 질문에 답하기 위해 툴을 사용합니다.",
+},
+{
+text: "RAG 툴을 포함한 모든 툴을 사용하여 질문에 답할지 결정할 수 있습니다",
+explain: "에이전트 RAG는 질문에 답하기 위해 다양한 툴을 사용할 수 있는 유연성을 가집니다.",
+correct: true
+},
+{
+text: "Function Calling Agents와만 작동합니다",
+explain: "에이전트 RAG는 Function Calling Agents에만 국한되지 않습니다.",
+}
+]}
+/>
+
+---
+
+
+이해하셨나요? 훌륭합니다! 이제 **단원에 대한 간단한 요약을 해보겠습니다!**
diff --git a/units/ko/unit2/llama-index/tools.mdx b/units/ko/unit2/llama-index/tools.mdx
new file mode 100644
index 00000000..6b9efb8b
--- /dev/null
+++ b/units/ko/unit2/llama-index/tools.mdx
@@ -0,0 +1,141 @@
+# LlamaIndex에서 툴 사용하기
+
+**명확한 툴 세트를 정의하는 것이 성능에 중요합니다.** [1단원](../../unit1/tools)에서 논의했듯이, 명확한 툴 인터페이스는 LLM이 사용하기 쉽습니다.
+인간 엔지니어를 위한 소프트웨어 API 인터페이스와 마찬가지로, 툴이 어떻게 작동하는지 이해하기 쉽다면 더 많은 것을 얻을 수 있습니다.
+
+**LlamaIndex에는 네 가지 주요 유형의 툴**이 있습니다:
+
+![툴](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/llama-index/tools.png)
+
+1. `FunctionTool`: 모든 Python 함수를 에이전트가 사용할 수 있는 툴로 변환합니다. 함수가 어떻게 작동하는지 자동으로 파악합니다.
+2. `QueryEngineTool`: 에이전트가 쿼리 엔진을 사용할 수 있게 하는 툴입니다. 에이전트는 쿼리 엔진 위에 구축되므로 다른 에이전트도 툴로 사용할 수 있습니다.
+3. `Toolspecs`: 커뮤니티에서 만든 툴 세트로, 종종 Gmail과 같은 특정 서비스를 위한 툴을 포함합니다.
+4. `Utility Tools`: 다른 툴에서 나오는 대량의 데이터를 처리하는 데 도움이 되는 특별한 툴입니다.
+
+아래에서 각각에 대해 더 자세히 살펴보겠습니다.
+
+## FunctionTool 만들기
+
+<Tip>
+<a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/llama-index/tools.ipynb" target="_blank">이 노트북</a>을 따라가며 Google Colab에서 코드를 실행해볼 수 있습니다.
+</Tip>
+
+FunctionTool은 모든 Python 함수를 래핑하고 에이전트가 사용할 수 있게 만드는 간단한 방법을 제공합니다.
+동기 또는 비동기 함수를 툴에 전달할 수 있으며, 선택적으로 `name`과 `description` 매개변수도 함께 전달할 수 있습니다.
+이름과 설명은 특히 중요합니다. 에이전트가 언제, 어떻게 툴을 효과적으로 사용할지 이해하는 데 도움이 되기 때문입니다.
+아래에서 FunctionTool을 만드는 방법을 살펴보고 호출해보겠습니다.
+
+```python
+from llama_index.core.tools import FunctionTool
+
+def get_weather(location: str) -> str:
+    """주어진 위치의 날씨를 가져오는 데 유용합니다."""
+    print(f"{location}의 날씨를 가져오는 중")
+    return f"{location}의 날씨는 맑습니다"
+
+tool = FunctionTool.from_defaults(
+    get_weather,
+    name="my_weather_tool",
+    description="주어진 위치의 날씨를 가져오는 데 유용합니다.",
+)
+tool.call("뉴욕")
+```
+
+<Tip>함수 호출이 있는 에이전트나 LLM을 사용할 때, 선택된 툴(그 툴에 대해 작성된 인수)은 툴의 목적과 인수에 대한 툴 이름과 설명에 크게 의존합니다. <a href="https://docs.llamaindex.ai/en/stable/examples/workflow/function_calling_agent/">함수 호출 가이드</a>에서 함수 호출에 대해 더 알아보세요.</Tip>
+
+## QueryEngineTool 만들기
+
+이전 단원에서 정의한 `QueryEngine`은 `QueryEngineTool` 클래스를 사용하여 쉽게 툴로 변환할 수 있습니다.
+아래 예제에서 `QueryEngine`에서 `QueryEngineTool`을 만드는 방법을 살펴보겠습니다.
+
+```python
+from llama_index.core import VectorStoreIndex
+from llama_index.core.tools import QueryEngineTool
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+from llama_index.vector_stores.chroma import ChromaVectorStore
+
+embed_model = HuggingFaceEmbedding("BAAI/bge-small-en-v1.5")
+
+db = chromadb.PersistentClient(path="./alfred_chroma_db")
+chroma_collection = db.get_or_create_collection("alfred")
+vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
+
+index = VectorStoreIndex.from_vector_store(vector_store, embed_model=embed_model)
+
+llm = HuggingFaceInferenceAPI(model_name="Qwen/Qwen2.5-Coder-32B-Instruct")
+query_engine = index.as_query_engine(llm=llm)
+tool = QueryEngineTool.from_defaults(query_engine, name="some useful name", description="some useful description")
+```
+
+## Toolspecs 만들기
+
+`ToolSpecs`를 조화롭게 함께 작동하는 툴 모음으로 생각하세요 - 잘 정리된 전문가 툴킷처럼요.
+정비사의 툴킷이 차량 수리를 위해 함께 작동하는 보완적인 툴들을 포함하는 것처럼, `ToolSpec`은 특정 목적을 위해 관련된 툴들을 결합합니다.
+예를 들어, 회계 에이전트의 `ToolSpec`은 스프레드시트 기능, 이메일 기능, 계산 툴을 우아하게 통합하여 재무 작업을 정확하고 효율적으로 처리할 수 있습니다.
+
+<details>
+<summary>Google Toolspec 설치</summary>
+<a href="./llama-hub">LlamaHub 섹션</a>에서 소개된 대로, 다음 명령어로 Google toolspec을 설치할 수 있습니다:
+
+```python
+pip install llama-index-tools-google
+```
+</details>
+
+이제 toolspec을 로드하고 툴 리스트로 변환할 수 있습니다.
+
+```python
+from llama_index.tools.google import GmailToolSpec
+
+tool_spec = GmailToolSpec()
+tool_spec_list = tool_spec.to_tool_list()
+```
+
+툴에 대한 더 자세한 보기를 얻기 위해 각 툴의 `metadata`를 살펴볼 수 있습니다.
+
+```python
+[(tool.metadata.name, tool.metadata.description) for tool in tool_spec_list]
+```
+
+### LlamaIndex의 모델 컨텍스트 프로토콜 (MCP)
+
+LlamaIndex는 [LlamaHub의 ToolSpec](https://llamahub.ai/l/tools/llama-index-tools-mcp?from=)을 통해 MCP 툴 사용도 허용합니다.
+단순히 MCP 서버를 실행하고 다음 구현을 통해 사용을 시작할 수 있습니다.
+
+MCP에 대해 더 깊이 알고 싶다면 [무료 MCP 강의](https://huggingface.co/learn/mcp-course/)를 확인할 수 있습니다.
+
+<details>
+<summary>MCP Toolspec 설치</summary>
+<a href="./llama-hub">LlamaHub 섹션</a>에서 소개된 대로, 다음 명령어로 MCP toolspec을 설치할 수 있습니다:
+
+```python
+pip install llama-index-tools-mcp
+```
+</details>
+
+```python
+from llama_index.tools.mcp import BasicMCPClient, McpToolSpec
+
+# 127.0.0.1:8000에서 실행 중인 mcp 서버가 있다고 가정하거나, mcp 클라이언트를 사용하여 자체 mcp 서버에 연결할 수 있습니다.
+mcp_client = BasicMCPClient("http://127.0.0.1:8000/sse")
+mcp_tool = McpToolSpec(client=mcp_client)
+
+# 에이전트 가져오기
+agent = await get_agent(mcp_tool)
+
+# 에이전트 컨텍스트 생성
+agent_context = Context(agent)
+```
+
+## 유틸리티 툴
+
+종종 API를 직접 쿼리하는 것은 **과도한 양의 데이터를 반환할 수 있으며**, 그 중 일부는 관련이 없거나, LLM의 컨텍스트 윈도우를 넘치거나, 사용하는 토큰 수를 불필요하게 증가시킬 수 있습니다.
+아래에서 두 가지 주요 유틸리티 툴을 살펴보겠습니다.
+
+1. `OnDemandToolLoader`: 이 툴은 기존 LlamaIndex 데이터 로더(BaseReader 클래스)를 에이전트가 사용할 수 있는 툴로 변환합니다. 툴은 데이터 로더에서 `load_data`를 트리거하는 데 필요한 모든 매개변수와 자연어 쿼리 문자열로 호출할 수 있습니다. 실행 중에 먼저 데이터 로더에서 데이터를 로드하고, 인덱싱하고(예를 들어 벡터 스토어로), 그런 다음 '온디맨드'로 쿼리합니다. 이 세 단계 모두가 단일 툴 호출에서 발생합니다.
+2. `LoadAndSearchToolSpec`: LoadAndSearchToolSpec은 기존 툴을 입력으로 받습니다. 툴 스펙으로서 `to_tool_list`를 구현하며, 해당 함수가 호출되면 두 개의 툴이 반환됩니다: 로딩 툴과 검색 툴입니다. 로드 툴 실행은 기본 툴을 호출한 다음 출력을 인덱싱합니다(기본적으로 벡터 인덱스로). 검색 툴 실행은 쿼리 문자열을 입력으로 받아 기본 인덱스를 호출합니다.
+
+<Tip>toolspecs와 유틸리티 툴은 <a href="https://llamahub.ai/">LlamaHub</a>에서 찾을 수 있습니다</Tip>
+
+이제 LlamaIndex에서 에이전트와 툴의 기본을 이해했으니, LlamaIndex를 사용하여 **구성 가능하고 관리 가능한 워크플로우를 만드는** 방법을 살펴보겠습니다!
diff --git a/units/ko/unit2/llama-index/workflows.mdx b/units/ko/unit2/llama-index/workflows.mdx
new file mode 100644
index 00000000..3b2e396e
--- /dev/null
+++ b/units/ko/unit2/llama-index/workflows.mdx
@@ -0,0 +1,280 @@
+# LlamaIndex에서 에이전트 워크플로우 만들기
+
+LlamaIndex의 워크플로우는 코드를 순차적이고 관리 가능한 단계로 구성하는 구조화된 방법을 제공합니다.
+
+이러한 워크플로우는 `Events`에 의해 트리거되는 `Steps`를 정의하여 생성되며, 이들 자체가 추가 단계를 트리거하기 위해 `Events`를 발생시킵니다.
+RAG 작업을 위한 LlamaIndex 워크플로우를 보여주는 알프레드를 살펴보겠습니다.
+
+![워크플로우 개요](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/llama-index/workflows.png)
+
+**워크플로우는 몇 가지 주요 이점을 제공합니다:**
+
+- 코드를 개별 단계로 명확하게 구성
+- 유연한 제어 흐름을 위한 이벤트 기반 아키텍처
+- 단계 간 타입 안전 통신
+- 내장 상태 관리
+- 간단하고 복잡한 에이전트 상호작용 모두 지원
+
+추측하셨을 수 있듯이, **워크플로우는 전체 워크플로우에 대한 제어를 유지하면서 에이전트의 자율성 사이에서 훌륭한 균형을 제공합니다.**
+
+그럼 우리만의 워크플로우를 만드는 방법을 배워보겠습니다!
+
+## 워크플로우 만들기
+
+<Tip>
+<a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/llama-index/workflows.ipynb" target="_blank">이 노트북</a>을 따라가며 Google Colab에서 코드를 실행해볼 수 있습니다.
+</Tip>
+
+### 기본 워크플로우 생성
+
+<details>
+<summary>워크플로우 패키지 설치</summary>
+<a href="./llama-hub">LlamaHub 섹션</a>에서 소개된 대로, 다음 명령어로 워크플로우 패키지를 설치할 수 있습니다:
+
+```python
+pip install llama-index-utils-workflow
+```
+</details>
+
+`Workflow`를 상속하는 클래스를 정의하고 함수에 `@step` 데코레이터를 사용하여 단일 단계 워크플로우를 만들 수 있습니다.
+또한 워크플로우의 시작과 끝을 나타내는 특별한 이벤트인 `StartEvent`와 `StopEvent`를 추가해야 합니다.
+
+```python
+from llama_index.core.workflow import StartEvent, StopEvent, Workflow, step
+
+class MyWorkflow(Workflow):
+    @step
+    async def my_step(self, ev: StartEvent) -> StopEvent:
+        # 여기서 무언가 수행
+        return StopEvent(result="안녕하세요, 세계!")
+
+
+w = MyWorkflow(timeout=10, verbose=False)
+result = await w.run()
+```
+
+보시다시피, 이제 `w.run()`을 호출하여 워크플로우를 실행할 수 있습니다.
+
+### 여러 단계 연결하기
+
+여러 단계를 연결하기 위해 **단계 간에 데이터를 전달하는 사용자 정의 이벤트를 만듭니다.**
+이를 위해 단계 간에 전달되고 첫 번째 단계의 출력을 두 번째 단계로 전송하는 `Event`를 추가해야 합니다.
+
+```python
+from llama_index.core.workflow import Event
+
+class ProcessingEvent(Event):
+    intermediate_result: str
+
+class MultiStepWorkflow(Workflow):
+    @step
+    async def step_one(self, ev: StartEvent) -> ProcessingEvent:
+        # 초기 데이터 처리
+        return ProcessingEvent(intermediate_result="1단계 완료")
+
+    @step
+    async def step_two(self, ev: ProcessingEvent) -> StopEvent:
+        # 중간 결과 사용
+        final_result = f"처리 완료: {ev.intermediate_result}"
+        return StopEvent(result=final_result)
+
+w = MultiStepWorkflow(timeout=10, verbose=False)
+result = await w.run()
+result
+```
+
+타입 힌팅은 워크플로우가 올바르게 실행되도록 보장하므로 여기서 중요합니다. 조금 더 복잡하게 만들어보겠습니다!
+
+### 루프와 분기
+
+타입 힌팅은 워크플로우의 가장 강력한 부분입니다. 더 복잡한 워크플로우를 용이하게 하기 위해 분기, 루프, 조인을 만들 수 있게 해주기 때문입니다.
+
+합집합 연산자 `|`를 사용하여 **루프를 만드는** 예제를 보여드리겠습니다.
+아래 예제에서 `LoopEvent`가 단계의 입력으로 사용되고 출력으로도 반환될 수 있음을 볼 수 있습니다.
+
+```python
+from llama_index.core.workflow import Event
+import random
+
+
+class ProcessingEvent(Event):
+    intermediate_result: str
+
+
+class LoopEvent(Event):
+    loop_output: str
+
+
+class MultiStepWorkflow(Workflow):
+    @step
+    async def step_one(self, ev: StartEvent | LoopEvent) -> ProcessingEvent | LoopEvent:
+        if random.randint(0, 1) == 0:
+            print("나쁜 일이 발생했습니다")
+            return LoopEvent(loop_output="1단계로 돌아갑니다.")
+        else:
+            print("좋은 일이 발생했습니다")
+            return ProcessingEvent(intermediate_result="첫 번째 단계 완료.")
+
+    @step
+    async def step_two(self, ev: ProcessingEvent) -> StopEvent:
+        # 중간 결과 사용
+        final_result = f"처리 완료: {ev.intermediate_result}"
+        return StopEvent(result=final_result)
+
+
+w = MultiStepWorkflow(verbose=False)
+result = await w.run()
+result
+```
+
+### 워크플로우 그리기
+
+워크플로우를 그릴 수도 있습니다. `draw_all_possible_flows` 함수를 사용하여 워크플로우를 그려보겠습니다. 이는 워크플로우를 HTML 파일에 저장합니다.
+
+```python
+from llama_index.utils.workflow import draw_all_possible_flows
+
+w = ... # 이전 섹션에서 정의된 대로
+draw_all_possible_flows(w, "flow.html")
+```
+
+![워크플로우 그리기](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/llama-index/workflow-draw.png)
+
+강의에서 다룰 마지막 멋진 트릭이 있는데, 그것은 워크플로우에 상태를 추가하는 능력입니다.
+
+### 상태 관리
+
+상태 관리는 워크플로우의 상태를 추적하고 싶을 때 유용하므로, 모든 단계가 동일한 상태에 접근할 수 있습니다.
+단계 함수의 매개변수 위에 `Context` 타입 힌팅을 사용하여 이를 수행할 수 있습니다.
+
+```python
+from llama_index.core.workflow import Context, StartEvent, StopEvent
+
+
+@step
+async def query(self, ctx: Context, ev: StartEvent) -> StopEvent:
+    # 컨텍스트에 쿼리 저장
+    await ctx.store.set("query", "프랑스의 수도는 무엇인가요?")
+
+    # 컨텍스트와 이벤트로 무언가 수행
+    val = ...
+
+    # 컨텍스트에서 쿼리 검색
+    query = await ctx.store.get("query")
+
+    return StopEvent(result=val)
+```
+
+훌륭합니다! 이제 LlamaIndex에서 기본 워크플로우를 만드는 방법을 알게 되었습니다!
+
+<Tip>워크플로우에는 더 복잡한 뉘앙스가 있으며, <a href="https://docs.llamaindex.ai/en/stable/understanding/workflows/">LlamaIndex 문서</a>에서 배울 수 있습니다.</Tip>
+
+하지만 `AgentWorkflow` 클래스에 의존하는 워크플로우를 만드는 다른 방법이 있습니다. 이를 사용하여 다중 에이전트 워크플로우를 만드는 방법을 살펴보겠습니다.
+
+## 다중 에이전트 워크플로우로 워크플로우 자동화
+
+수동 워크플로우 생성 대신 **`AgentWorkflow` 클래스를 사용하여 다중 에이전트 워크플로우를 만들** 수 있습니다.
+`AgentWorkflow`는 워크플로우 에이전트를 사용하여 전문화된 기능을 기반으로 협업하고 서로에게 작업을 넘길 수 있는 하나 이상의 에이전트 시스템을 만들 수 있게 해줍니다.
+이를 통해 서로 다른 에이전트가 작업의 서로 다른 측면을 처리하는 복잡한 에이전트 시스템을 구축할 수 있습니다.
+`llama_index.core.agent`에서 클래스를 가져오는 대신, `llama_index.core.agent.workflow`에서 에이전트 클래스를 가져올 것입니다.
+하나의 에이전트는 `AgentWorkflow` 생성자에서 루트 에이전트로 지정되어야 합니다.
+사용자 메시지가 들어오면 먼저 루트 에이전트로 라우팅됩니다.
+
+각 에이전트는 다음을 수행할 수 있습니다:
+
+- 툴을 사용하여 요청을 직접 처리
+- 작업에 더 적합한 다른 에이전트에게 작업 넘기기
+- 사용자에게 응답 반환
+
+다중 에이전트 워크플로우를 만드는 방법을 살펴보겠습니다.
+
+```python
+from llama_index.core.agent.workflow import AgentWorkflow, ReActAgent
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+
+# 몇 가지 툴 정의
+def add(a: int, b: int) -> int:
+    """두 숫자를 더합니다."""
+    return a + b
+
+def multiply(a: int, b: int) -> int:
+    """두 숫자를 곱합니다."""
+    return a * b
+
+llm = HuggingFaceInferenceAPI(model_name="Qwen/Qwen2.5-Coder-32B-Instruct")
+
+# FunctionTool 없이 함수를 직접 전달할 수 있습니다 -- 함수/독스트링이 이름/설명을 위해 파싱됩니다
+multiply_agent = ReActAgent(
+    name="multiply_agent",
+    description="두 정수를 곱할 수 있습니다",
+    system_prompt="숫자를 곱하는 툴을 사용할 수 있는 도움이 되는 어시스턴트입니다.",
+    tools=[multiply],
+    llm=llm,
+)
+
+addition_agent = ReActAgent(
+    name="add_agent",
+    description="두 정수를 더할 수 있습니다",
+    system_prompt="숫자를 더하는 툴을 사용할 수 있는 도움이 되는 어시스턴트입니다.",
+    tools=[add],
+    llm=llm,
+)
+
+# 워크플로우 생성
+workflow = AgentWorkflow(
+    agents=[multiply_agent, addition_agent],
+    root_agent="multiply_agent",
+)
+
+# 시스템 실행
+response = await workflow.run(user_msg="5와 3을 더할 수 있나요?")
+```
+
+에이전트 툴은 앞서 언급한 워크플로우 상태도 수정할 수 있습니다. 워크플로우를 시작하기 전에 모든 에이전트가 사용할 수 있는 초기 상태 딕셔너리를 제공할 수 있습니다.
+상태는 워크플로우 컨텍스트의 상태 키에 저장됩니다. 각 새로운 사용자 메시지를 보강하는 state_prompt에 주입됩니다.
+
+이전 예제를 수정하여 함수 호출을 세는 카운터를 주입해보겠습니다:
+
+```python
+from llama_index.core.workflow import Context
+
+# 몇 가지 툴 정의
+async def add(ctx: Context, a: int, b: int) -> int:
+    """두 숫자를 더합니다."""
+    # 카운트 업데이트
+    cur_state = await ctx.store.get("state")
+    cur_state["num_fn_calls"] += 1
+    await ctx.store.set("state", cur_state)
+
+    return a + b
+
+async def multiply(ctx: Context, a: int, b: int) -> int:
+    """두 숫자를 곱합니다."""
+    # 카운트 업데이트
+    cur_state = await ctx.store.get("state")
+    cur_state["num_fn_calls"] += 1
+    await ctx.store.set("state", cur_state)
+
+    return a * b
+
+...
+
+workflow = AgentWorkflow(
+    agents=[multiply_agent, addition_agent],
+    root_agent="multiply_agent",
+    initial_state={"num_fn_calls": 0},
+    state_prompt="현재 상태: {state}. 사용자 메시지: {msg}",
+)
+
+# 컨텍스트와 함께 워크플로우 실행
+ctx = Context(workflow)
+response = await workflow.run(user_msg="5와 3을 더할 수 있나요?", ctx=ctx)
+
+# 상태를 꺼내서 검사
+state = await ctx.store.get("state")
+print(state["num_fn_calls"])
+```
+
+축하합니다! 이제 LlamaIndex에서 에이전트의 기본을 마스터했습니다! 🎉
+
+지식을 확고히 하기 위해 마지막 퀴즈를 계속해보겠습니다! 🚀
diff --git a/units/ko/unit2/smolagents/code_agents.mdx b/units/ko/unit2/smolagents/code_agents.mdx
new file mode 100644
index 00000000..fcba655d
--- /dev/null
+++ b/units/ko/unit2/smolagents/code_agents.mdx
@@ -0,0 +1,389 @@
+<CourseFloatingBanner
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/#fileId=https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/code_agents.ipynb"},
+]}
+askForHelpUrl="http://hf.co/join/discord"
+ />
+
+# 코드를 사용하는 에이전트 만들기
+
+코드 에이전트는 `smolagents`의 기본 에이전트 유형입니다. 이들은 파이썬 도구 호출을 생성하여 작업을 수행하며, 효율적이고 표현력 있으며 정확한 액션 표현을 달성합니다.
+
+이러한 간소화된 접근 방식은 필요한 액션 수를 줄이고, 복잡한 작업을 단순화하며, 기존 코드 함수의 재사용을 가능하게 합니다. `smolagents`는 약 1,000줄의 코드로 구현된 경량 프레임워크를 제공합니다.
+
+![코드 vs JSON 액션](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/code_vs_json_actions.png)
+위 이미지는 논문 [Executable Code Actions Elicit Better LLM Agents](https://huggingface.co/papers/2402.01030)에서 가져왔습니다.
+
+<Tip>
+코드 에이전트가 왜 효과적인지 더 알고 싶다면, smolagents 문서의 <a href="https://huggingface.co/docs/smolagents/en/conceptual_guides/intro_agents#code-agents" target="_blank">이 가이드</a>를 참고하세요.
+</Tip>
+
+## 왜 코드 에이전트인가요?
+
+다단계 에이전트 프로세스에서 LLM은 일반적으로 외부 도구 호출을 포함하는 액션을 작성하고 실행합니다. 기존 방식은 도구 이름과 인자를 문자열로 지정하는 JSON 형식을 사용하며, **시스템이 어떤 도구를 실행할지 파싱해야 합니다**.
+
+하지만 연구 결과에 따르면, **도구 호출 LLM은 직접 코드를 사용할 때 더 효과적으로 작동합니다**. 이것이 `smolagents`의 핵심 원칙이며, 위의 논문 이미지에서도 확인할 수 있습니다.
+
+코드로 액션을 작성하면 다음과 같은 주요 장점이 있습니다:
+
+* **조합성**: 액션을 쉽게 결합하고 재사용할 수 있습니다.
+* **객체 관리**: 이미지와 같은 복잡한 구조를 직접 다룰 수 있습니다.
+* **범용성**: 계산적으로 가능한 모든 작업을 표현할 수 있습니다.
+* **LLM에 자연스러움**: 고품질 코드는 이미 LLM의 학습 데이터에 풍부하게 포함되어 있습니다.
+
+## 코드 에이전트는 어떻게 동작하나요?
+
+![https://huggingface.co/docs/smolagents/conceptual_guides/react에서 가져옴](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/smolagents/codeagent_docs.png)
+
+위 다이어그램은 `CodeAgent.run()`이 어떻게 동작하는지 보여줍니다. 이는 1단원에서 언급한 ReAct 프레임워크를 따릅니다. `smolagents`에서 에이전트의 주요 추상화는 `MultiStepAgent`이며, 이는 핵심 빌딩 블록 역할을 합니다. `CodeAgent`는 특별한 종류의 `MultiStepAgent`입니다.
+
+`CodeAgent`는 다음과 같은 단계로 동작합니다. 기존 변수와 지식은 실행 로그에 저장되어 에이전트의 컨텍스트로 활용됩니다:
+
+1. 시스템 프롬프트는 `SystemPromptStep`에 저장되고, 사용자 쿼리는 `TaskStep`에 기록됩니다.
+
+2. 그 다음, 다음과 같은 while 루프가 실행됩니다:
+
+    2.1 `agent.write_memory_to_messages()` 메서드는 에이전트의 로그를 LLM이 읽을 수 있는 [채팅 메시지](https://huggingface.co/docs/transformers/main/en/chat_templating) 리스트로 변환합니다.
+    
+    2.2 이 메시지들은 `Model`로 전송되어 응답을 생성합니다.
+    
+    2.3 응답에서 액션을 추출하는데, 코드 에이전트이므로 파이썬 코드 조각이어야 합니다.
+    
+    2.4 액션이 실행됩니다.
+    
+    2.5 결과가 `ActionStep`에 메모리로 기록됩니다.
+
+각 단계가 끝날 때, 에이전트에 함수 호출(`agent.step_callback`)이 포함되어 있다면 실행됩니다.
+
+## 예시로 알아보기
+
+<Tip>
+<a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/code_agents.ipynb" target="_blank">이 노트북</a>을 따라가며 코드를 직접 실행해볼 수 있습니다.
+</Tip>
+
+Alfred는 웨인 가문의 저택에서 파티를 준비하고 있습니다. 모든 것이 순조롭게 진행되도록 여러분의 도움이 필요합니다. 지금까지 배운 다단계 `CodeAgent`의 동작 방식을 적용해봅시다.
+
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/smolagents/alfred-party.jpg" alt="Alfred Party"/>
+
+아직 `smolagents`를 설치하지 않았다면, 다음 명령어로 설치하세요:
+
+```bash
+pip install smolagents -U
+```
+
+Hugging Face Hub에 로그인하여 Serverless Inference API를 사용할 수 있도록 합니다.
+
+```python
+from huggingface_hub import login
+
+login()
+```
+
+### `smolagents`로 파티 플레이리스트 선택하기
+
+음악은 파티의 필수 요소입니다! Alfred는 플레이리스트를 고르는 데 도움이 필요합니다. 다행히도 `smolagents`를 사용하면 웹 검색 도구를 에이전트에 추가하여 이를 해결할 수 있습니다.
+
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/smolagents/alfred-playlist.jpg" alt="Alfred Playlist"/>
+
+모델로는 Hugging Face의 [Serverless Inference API](https://huggingface.co/docs/api-inference/index)에 접근할 수 있는 `InferenceClientModel`을 사용합니다. 기본 모델은 "Qwen/Qwen2.5-Coder-32B-Instruct"이며, 빠른 추론이 가능합니다. 허브에서 호환되는 다른 모델도 선택할 수 있습니다.
+
+에이전트 실행은 매우 간단합니다:
+
+```python
+from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel
+
+agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=InferenceClientModel())
+
+agent.run("웨인 저택에서 열리는 파티에 어울리는 최고의 음악 추천을 검색해줘.")
+```
+
+이 예시를 실행하면 **워크플로우 단계의 실행 추적**이 출력됩니다. 또한 다음과 같은 파이썬 코드가 표시됩니다:
+
+```python
+ ─ 실행된 파싱 코드: ─────────────────────────────────────────────────────────────── 
+  results = web_search(query="배트맨 파티에 어울리는 최고의 음악")                                                       
+  print(results)                                                                                                    
+ ───────────────────────────────────────────────────────────────────────────────────── 
+```
+
+몇 단계 후, Alfred가 사용할 수 있는 플레이리스트가 생성됩니다! 🎵
+
+### 맞춤형 도구로 메뉴 준비하기
+
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/smolagents/alfred-menu.jpg" alt="Alfred Menu"/>
+
+플레이리스트를 골랐다면, 이제 손님을 위한 메뉴를 준비해야 합니다. Alfred는 여기서도 `smolagents`의 도움을 받을 수 있습니다. 아래 예시에서는 `@tool` 데코레이터를 사용해 맞춤형 함수를 도구로 등록합니다. 도구 생성에 대해서는 이후에 더 자세히 다루니, 지금은 코드를 실행해보세요.
+
+아래 예시처럼, `@tool` 데코레이터로 도구를 만들고 `tools` 리스트에 추가합니다.
+
+```python
+from smolagents import CodeAgent, tool, InferenceClientModel
+
+# 파티 상황에 맞는 메뉴를 추천하는 도구
+@tool
+def suggest_menu(occasion: str) -> str:
+    """
+    상황에 따라 메뉴를 추천합니다.
+    Args:
+        occasion (str): 파티 유형. 허용 값:
+                        - "casual": 캐주얼 파티 메뉴
+                        - "formal": 포멀 파티 메뉴
+                        - "superhero": 슈퍼히어로 파티 메뉴
+                        - "custom": 맞춤 메뉴
+    """
+    if occasion == "casual":
+        return "피자, 스낵, 음료."
+    elif occasion == "formal":
+        return "3코스 디너, 와인, 디저트."
+    elif occasion == "superhero":
+        return "고에너지, 건강식 뷔페."
+    else:
+        return "집사만을 위한 맞춤 메뉴."
+
+# Alfred가 파티 메뉴를 준비합니다
+agent = CodeAgent(tools=[suggest_menu], model=InferenceClientModel())
+
+# 파티를 위한 포멀 메뉴 준비
+agent.run("파티를 위한 포멀 메뉴를 준비해줘.")
+```
+
+에이전트는 몇 단계 실행 후 답을 찾습니다. docstring에 허용 값을 명확히 적으면 에이전트가 `occasion` 인자 값을 올바르게 사용하도록 유도할 수 있습니다.
+
+메뉴 준비 완료! 🥗
+
+### 에이전트 내에서 파이썬 import 사용하기
+
+플레이리스트와 메뉴가 준비되었으니, 이제 남은 것은 준비 시간 계산입니다!
+
+Alfred는 모든 준비를 지금 시작하면 언제 파티가 준비될지 계산해야 합니다. 필요하다면 다른 슈퍼히어로의 도움도 받을 수 있겠죠.
+
+`smolagents`는 파이썬 코드 조각을 작성하고 실행하는 에이전트에 특화되어 있으며, 보안을 위해 샌드박스 실행을 제공합니다.
+
+**코드 실행에는 엄격한 보안 조치가 적용됩니다** — 기본적으로 허용된 목록 외의 import는 차단됩니다. 하지만 `additional_authorized_imports`에 문자열로 추가하면 import를 허용할 수 있습니다.
+자세한 보안 실행 방법은 공식 [가이드](https://huggingface.co/docs/smolagents/tutorials/secure_code_execution)를 참고하세요.
+
+아래 예시에서는 `datetime` 모듈 import를 허용합니다.
+
+```python
+from smolagents import CodeAgent, InferenceClientModel
+import numpy as np
+import time
+import datetime
+
+agent = CodeAgent(tools=[], model=InferenceClientModel(), additional_authorized_imports=['datetime'])
+
+agent.run(
+    """
+    Alfred가 파티를 준비해야 합니다. 작업 목록:
+    1. 음료 준비 - 30분
+    2. 저택 장식 - 60분
+    3. 메뉴 세팅 - 45분
+    4. 음악 및 플레이리스트 준비 - 45분
+
+    지금 바로 시작하면 파티 준비가 언제 끝날까요?
+    """
+)
+```
+
+이 예시들은 코드 에이전트로 할 수 있는 일의 시작에 불과합니다. 더 많은 내용은 [smolagents 문서](https://huggingface.co/docs/smolagents)에서 확인하세요.
+
+요약하자면, `smolagents`는 파이썬 코드 조각을 작성하고 실행하는 에이전트에 특화되어 있으며, 보안 샌드박스 실행을 지원합니다. 로컬 및 API 기반 언어 모델 모두 지원하여 다양한 개발 환경에 적합합니다.
+
+### 우리만의 파티 준비 에이전트를 허브에 공유하기
+
+우리만의 Alfred 에이전트를 커뮤니티에 공유할 수 있다면 정말 멋지지 않을까요? 누구나 허브에서 쉽게 다운로드해 사용할 수 있습니다! `smolagents`는 완성된 에이전트를 커뮤니티에 공유하고, 다른 사람의 에이전트를 즉시 다운로드할 수 있도록 지원합니다. 방법은 다음과 같이 간단합니다:
+
+```python
+# 사용자명과 저장소명을 변경하세요
+agent.push_to_hub('sergiopaniego/AlfredAgent')
+```
+
+다시 다운로드하려면 아래 코드를 사용하세요:
+
+```python
+# 사용자명과 저장소명을 변경하세요
+alfred_agent = agent.from_hub('sergiopaniego/AlfredAgent', trust_remote_code=True)
+
+alfred_agent.run("웨인 저택에서 열리는 파티에 어울리는 최고의 플레이리스트를 추천해줘. 파티 테마는 '빌런 가면무도회'야")  
+```
+
+공유된 에이전트는 Hugging Face Spaces에서도 바로 사용할 수 있습니다. [여기](https://huggingface.co/spaces/davidberenstein1957/smolagents-and-tools)에서 다양한 에이전트를 탐색해보세요.
+
+예를 들어, _AlfredAgent_는 [여기](https://huggingface.co/spaces/sergiopaniego/AlfredAgent)에서 바로 사용할 수 있습니다. 아래에서 직접 체험해보세요:
+
+<iframe
+	src="https://sergiopaniego-alfredagent.hf.space/"
+	frameborder="0"
+	width="850"
+	height="450"
+></iframe>
+
+Alfred가 어떻게 이런 에이전트를 만들었는지 궁금하다면, 여러 도구를 통합해 아래와 같이 에이전트를 생성할 수 있습니다. 도구에 대해서는 이후에 자세히 다루니, 지금은 구조만 참고하세요:
+
+```python
+from smolagents import CodeAgent, DuckDuckGoSearchTool, FinalAnswerTool, InferenceClientModel, Tool, tool, VisitWebpageTool
+
+@tool
+def suggest_menu(occasion: str) -> str:
+    """
+    상황에 따라 메뉴를 추천합니다.
+    Args:
+        occasion: 파티 유형
+    """
+    if occasion == "casual":
+        return "피자, 스낵, 음료."
+    elif occasion == "formal":
+        return "3코스 디너, 와인, 디저트."
+    elif occasion == "superhero":
+        return "고에너지, 건강식 뷔페."
+    else:
+        return "집사만을 위한 맞춤 메뉴."
+
+@tool
+def catering_service_tool(query: str) -> str:
+    """
+    이 도구는 고담시에서 평점이 가장 높은 케이터링 서비스를 반환합니다.
+    
+    Args:
+        query: 케이터링 서비스 검색어
+    """
+    # 예시 케이터링 서비스와 평점
+    services = {
+        "Gotham Catering Co.": 4.9,
+        "Wayne Manor Catering": 4.8,
+        "Gotham City Events": 4.7,
+    }
+    
+    # 평점이 가장 높은 서비스 찾기(검색어 필터링 시뮬레이션)
+    best_service = max(services, key=services.get)
+    
+    return best_service
+
+class SuperheroPartyThemeTool(Tool):
+    name = "superhero_party_theme_generator"
+    description = """
+    이 도구는 카테고리에 따라 창의적인 슈퍼히어로 테마 파티 아이디어를 제안합니다.
+    고유한 파티 테마 아이디어를 반환합니다."""
+    
+    inputs = {
+        "category": {
+            "type": "string",
+            "description": "슈퍼히어로 파티 유형(예: 'classic heroes', 'villain masquerade', 'futuristic Gotham')",
+        }
+    }
+    
+    output_type = "string"
+
+    def forward(self, category: str):
+        themes = {
+            "classic heroes": "Justice League Gala: 손님들이 DC 영웅으로 분장하고 '크립토나이트 펀치' 같은 테마 칵테일을 즐깁니다.",
+            "villain masquerade": "Gotham Rogues' Ball: 손님들이 배트맨 빌런으로 분장하는 신비로운 가면무도회.",
+            "futuristic Gotham": "Neo-Gotham Night: 배트맨 비욘드에서 영감을 받은 사이버펑크 스타일 파티, 네온 장식과 미래형 소품.",
+        }
+        
+        return themes.get(category.lower(), "테마 파티 아이디어를 찾을 수 없습니다. 'classic heroes', 'villain masquerade', 'futuristic Gotham' 중에서 시도해보세요.")
+
+
+# Alfred가 파티 메뉴를 준비합니다
+agent = CodeAgent(
+    tools=[
+        DuckDuckGoSearchTool(), 
+        VisitWebpageTool(),
+        suggest_menu,
+        catering_service_tool,
+        SuperheroPartyThemeTool(),
+	FinalAnswerTool()
+    ], 
+    model=InferenceClientModel(),
+    max_steps=10,
+    verbosity_level=2
+)
+
+agent.run("웨인 저택에서 열리는 파티에 어울리는 최고의 플레이리스트를 추천해줘. 파티 테마는 '빌런 가면무도회'야")
+```
+
+이처럼 여러 도구를 결합해 `CodeAgent`를 만들면, 커뮤니티와 공유할 수 있는 궁극의 파티 플래너가 완성됩니다! 🎉
+
+이제 여러분 차례입니다: 자신만의 에이전트를 만들어 허브에 공유해보세요! 🕵️‍♂️💡
+
+<Tip>
+여러분의 에이전트 프로젝트를 공유하고 싶다면, Hugging Face Hub에 space를 만들고 <a href="https://huggingface.co/agents-course">agents-course</a> 태그를 달아주세요. 여러분의 작품을 기다리고 있습니다!
+</Tip>
+
+### OpenTelemetry와 Langfuse로 파티 준비 에이전트 추적하기 📡
+
+Alfred는 파티 준비 에이전트를 다듬으면서 실행을 디버깅하는 데 지쳐가고 있습니다. 에이전트는 본질적으로 예측 불가능하고, 동작을 추적하기 어렵기 때문입니다. 하지만 궁극의 파티 준비 에이전트를 만들어 배포하려면, 미래의 모니터링과 분석을 위한 강력한 추적 기능이 필요합니다.
+
+여기서도 `smolagents`가 해결책을 제공합니다! [OpenTelemetry](https://opentelemetry.io/) 표준을 채택해 에이전트 실행을 계측하고, [Langfuse](https://langfuse.com/) 및 `SmolagentsInstrumentor`를 통해 동작을 쉽게 추적·분석할 수 있습니다.
+
+설정 방법은 다음과 같이 간단합니다!
+
+먼저, 필요한 의존성을 설치합니다:
+
+```bash
+pip install opentelemetry-sdk opentelemetry-exporter-otlp openinference-instrumentation-smolagents
+```
+
+Alfred는 이미 Langfuse 계정을 만들고 API 키를 준비했습니다. 아직 계정이 없다면 [여기](https://cloud.langfuse.com/)에서 가입하거나 [대안](https://huggingface.co/docs/smolagents/tutorials/inspect_runs)을 참고하세요.
+
+API 키를 아래와 같이 환경 변수로 설정합니다:
+
+```python
+import os
+import base64
+
+LANGFUSE_PUBLIC_KEY="pk-lf-..."
+LANGFUSE_SECRET_KEY="sk-lf-..."
+LANGFUSE_AUTH=base64.b64encode(f"{LANGFUSE_PUBLIC_KEY}:{LANGFUSE_SECRET_KEY}".encode()).decode()
+
+os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "https://cloud.langfuse.com/api/public/otel" # EU 데이터 리전
+# os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "https://us.cloud.langfuse.com/api/public/otel" # US 데이터 리전
+os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"Authorization=Basic {LANGFUSE_AUTH}"
+```
+
+마지막으로, `SmolagentsInstrumentor`를 초기화해 추적을 시작합니다.
+
+```python
+from opentelemetry.sdk.trace import TracerProvider
+
+from openinference.instrumentation.smolagents import SmolagentsInstrumentor
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+
+trace_provider = TracerProvider()
+trace_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter()))
+
+SmolagentsInstrumentor().instrument(tracer_provider=trace_provider)
+```
+
+이제 Alfred는 연결 완료! 🔌 `smolagents`의 실행이 Langfuse에 기록되어, 에이전트의 동작을 완벽하게 추적할 수 있습니다. 이 설정으로 이전 실행을 다시 확인하고, 파티 준비 에이전트를 더욱 개선할 수 있습니다.
+
+<Tip>에이전트 추적 및 평가 데이터 활용법은 <a href="https://huggingface.co/learn/agents-course/bonus-unit2/introduction">보너스 2단원</a>에서 더 자세히 다룹니다.</Tip>
+
+```python
+from smolagents import CodeAgent, InferenceClientModel
+
+agent = CodeAgent(tools=[], model=InferenceClientModel())
+alfred_agent = agent.from_hub('sergiopaniego/AlfredAgent', trust_remote_code=True)
+alfred_agent.run("웨인 저택에서 열리는 파티에 어울리는 최고의 플레이리스트를 추천해줘. 파티 테마는 '빌런 가면무도회'야")  
+```
+
+Alfred는 이제 [여기](https://cloud.langfuse.com/project/cm7bq0abj025rad078ak3luwi/traces/995fc019255528e4f48cf6770b0ce27b?timestamp=2025-02-19T10%3A28%3A36.929Z)에서 로그를 확인하고 분석할 수 있습니다.
+
+<Tip>
+실행 중에 작은 오류가 발생했습니다. 로그에서 오류를 찾아볼 수 있나요? 에이전트가 어떻게 오류를 처리하고 유효한 답을 반환하는지 추적해보세요. <a href="https://cloud.langfuse.com/project/cm7bq0abj025rad078ak3luwi/traces/995fc019255528e4f48cf6770b0ce27b?timestamp=2025-02-19T10%3A28%3A36.929Z&observation=80ca57ace4f69b52">여기</a>에서 오류를 직접 확인할 수 있습니다. 물론 오류는 이미 수정되었으며, 자세한 내용은 <a href="https://github.com/huggingface/smolagents/issues/838">이 이슈</a>에서 확인할 수 있습니다.
+</Tip>
+
+한편, [추천 플레이리스트](https://open.spotify.com/playlist/0gZMMHjuxMrrybQ7wTMTpw)가 파티 준비 분위기를 완성해줍니다. 멋지죠? 🎶
+
+---
+
+이제 첫 번째 코드 에이전트를 만들었으니, **이제 smolagents에서 제공하는 두 번째 에이전트 유형인 Tool Calling Agent 만드는 법**을 배워봅시다.
+
+## 참고 자료
+
+- [smolagents 블로그](https://huggingface.co/blog/smolagents) - smolagents 및 코드 인터랙션 소개
+- [smolagents: 좋은 에이전트 만들기](https://huggingface.co/docs/smolagents/tutorials/building_good_agents) - 신뢰성 높은 에이전트 구축을 위한 베스트 프랙티스
+- [Anthropic: 효과적인 에이전트 만들기](https://www.anthropic.com/research/building-effective-agents) - 에이전트 설계 원칙
+- [OpenTelemetry로 실행 공유하기](https://huggingface.co/docs/smolagents/tutorials/inspect_runs) - 에이전트 추적 설정 방법
diff --git a/units/ko/unit2/smolagents/conclusion.mdx b/units/ko/unit2/smolagents/conclusion.mdx
new file mode 100644
index 00000000..a50f77b2
--- /dev/null
+++ b/units/ko/unit2/smolagents/conclusion.mdx
@@ -0,0 +1,11 @@
+# 결론
+
+`smolagents` 모듈(2단원)을 마친 것을 축하합니다 🥳
+
+이제 `smolagents`의 기본을 마스터했고, 나만의 에이전트도 만들어보았습니다! 이제 여러분은 관심 있는 문제를 해결하는 에이전트를 직접 만들 수 있는 역량을 갖추었습니다.
+
+다음 모듈에서는 **LlamaIndex로 에이전트 만드는 법**을 배울 예정입니다.
+
+마지막으로, **이 과정에 대한 여러분의 의견과 개선점**을 듣고 싶습니다. 피드백이 있다면 👉 [이 양식](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog)을 작성해 주세요.
+
+### 계속 배우고, 멋진 하루 보내세요 🤗
diff --git a/units/ko/unit2/smolagents/final_quiz.mdx b/units/ko/unit2/smolagents/final_quiz.mdx
new file mode 100644
index 00000000..28658723
--- /dev/null
+++ b/units/ko/unit2/smolagents/final_quiz.mdx
@@ -0,0 +1,25 @@
+# 시험 시간!
+
+`smolagents` 학습을 마친 여러분, 정말 수고 많으셨습니다! 이제 퀴즈로 여러분의 지식을 점검해볼 시간입니다. 🧠
+
+## 안내사항
+
+- 퀴즈는 코드 문제로 구성되어 있습니다.
+- 코드 조각을 완성하는 지시사항이 주어집니다.
+- 안내를 잘 읽고, 코드 조각을 완성해 주세요.
+- 각 문제마다 결과와 피드백이 제공됩니다.
+
+🧘 **이 퀴즈는 점수화되거나 인증되지 않습니다**. 여러분이 `smolagents` 라이브러리를 잘 이해했는지, 추가 학습이 필요한지 스스로 점검하는 용도입니다. 다음 단원에서는 이 지식을 실제 사례와 프로젝트에 적용해볼 예정입니다.
+
+시작해볼까요? 
+
+## 퀴즈 🚀
+
+<iframe
+    src="https://agents-course-unit2-smolagents-quiz.hf.space"
+    frameborder="0"
+    width="850"
+    height="450"
+></iframe>
+
+퀴즈에 직접 참여하려면 👉 [여기](https://huggingface.co/spaces/agents-course/unit2_smolagents_quiz)로 이동하세요.
\ No newline at end of file
diff --git a/units/ko/unit2/smolagents/introduction.mdx b/units/ko/unit2/smolagents/introduction.mdx
new file mode 100644
index 00000000..569d43f5
--- /dev/null
+++ b/units/ko/unit2/smolagents/introduction.mdx
@@ -0,0 +1,67 @@
+# `smolagents` 소개
+
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/smolagents/thumbnail.jpg" alt="Unit 2.1 Thumbnail"/>
+
+이 모듈에 오신 것을 환영합니다! 여기서는 [`smolagents`](https://github.com/huggingface/smolagents) 라이브러리를 활용해 **효과적인 에이전트 만드는 법**을 배웁니다. `smolagents`는 강력한 AI 에이전트를 손쉽게 만들 수 있도록 도와주는 경량 프레임워크입니다.
+
+`smolagents`는 Hugging Face에서 제공하는 라이브러리입니다. [`저장소`](https://github.com/huggingface/smolagents)에 **별(star)**을 눌러 응원해 주세요!
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/smolagents/star_smolagents.gif" alt="staring smolagents"/>
+
+## 모듈 개요
+
+이 모듈에서는 `smolagents`를 활용해 지능형 에이전트를 만드는 데 필요한 핵심 개념과 실전 전략을 폭넓게 다룹니다.
+
+수많은 오픈소스 프레임워크가 존재하는 만큼, `smolagents`의 구성 요소와 장단점을 이해하고, 언제 다른 솔루션이 더 적합할지 판단하는 것이 중요합니다.
+
+이 단원에서는 소프트웨어 개발에 특화된 코드 에이전트, 모듈형 워크플로우를 위한 툴 호출 에이전트, 정보를 검색·종합하는 리트리벌 에이전트 등 주요 에이전트 유형을 살펴봅니다.
+
+또한 여러 에이전트를 조합하는 방법, 비전 기능 및 웹 브라우징 통합 등 동적이고 상황 인식이 가능한 애플리케이션을 만드는 방법도 다룹니다.
+
+이번 단원에서는 1단원에서 만난 에이전트 Alfred가 다시 등장합니다. 이번에는 `smolagents` 프레임워크를 활용해 다양한 작업을 해결합니다. Alfred는 Wayne 저택에서 파티를 준비하며 여러 과제를 해결해야 합니다. Alfred의 여정을 따라가며 `smolagents`의 핵심 개념을 함께 익혀봅시다!
+
+<Tip>
+이 단원에서는 `smolagents` 라이브러리로 AI 에이전트를 만드는 법을 배웁니다. 여러분의 에이전트는 데이터 검색, 코드 실행, 웹페이지 상호작용이 가능하며, 여러 에이전트를 조합해 더 강력한 시스템도 만들 수 있습니다.
+</Tip>
+
+![Alfred the agent](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/this-is-alfred.jpg)
+
+## 목차
+
+이 단원에서 다루는 내용은 다음과 같습니다:
+
+### 1️⃣ [왜 smolagents를 사용할까](./why_use_smolagents)
+
+`smolagents`는 다양한 오픈소스 에이전트 프레임워크 중 하나입니다. 대안으로는 `LlamaIndex`, `LangGraph` 등이 있으며, 이 과정의 다른 모듈에서 다룹니다. `smolagents`는 특정 상황에 적합한 여러 주요 기능을 제공하지만, 프레임워크 선택 시 항상 다양한 옵션을 고려해야 합니다. 이 장에서는 `smolagents`의 장단점을 살펴보고, 프로젝트 요구에 따라 현명하게 선택할 수 있도록 도와줍니다.
+
+### 2️⃣ [CodeAgents](./code_agents)
+
+`CodeAgents`는 `smolagents`의 기본 에이전트 유형입니다. 이들은 JSON이나 텍스트 대신 파이썬 코드를 생성해 작업을 수행합니다. 이 장에서는 CodeAgent의 목적, 동작 방식, 실전 예시를 통해 그 기능을 살펴봅니다.
+
+### 3️⃣ [ToolCallingAgents](./tool_calling_agents)
+
+`ToolCallingAgents`는 `smolagents`가 지원하는 두 번째 에이전트 유형입니다. CodeAgent가 파이썬 코드를 생성하는 것과 달리, 이 에이전트는 시스템이 파싱·해석해야 하는 JSON/텍스트 블롭을 생성합니다. 이 장에서는 ToolCallingAgent의 동작 방식, CodeAgent와의 차이점, 사용 예시를 다룹니다.
+
+### 4️⃣ [도구(Tools)](./tools)
+
+1단원에서 살펴본 것처럼, 도구는 LLM이 에이전트 시스템 내에서 사용할 수 있는 함수로, 에이전트 행동의 핵심 빌딩 블록입니다. 이 장에서는 도구 생성법, 구조, `Tool` 클래스와 `@tool` 데코레이터를 활용한 다양한 구현 방법을 다룹니다. 기본 도구 상자, 커뮤니티에 도구 공유, 커뮤니티 도구 불러오기 등도 배웁니다.
+
+### 5️⃣ [리트리벌 에이전트(Retrieval Agents)](./retrieval_agents)
+
+리트리벌 에이전트는 모델이 지식 베이스에 접근할 수 있게 하여, 다양한 소스에서 정보를 검색·종합·추출할 수 있게 합니다. 이들은 벡터 스토어를 활용해 효율적으로 정보를 찾고, **RAG(Retrieval-Augmented Generation)** 패턴을 구현합니다. 웹 검색과 맞춤형 지식 베이스 통합, 대화 맥락 유지 등 다양한 전략을 다룹니다.
+
+### 6️⃣ [멀티 에이전트 시스템(Multi-Agent Systems)](./multi_agent_systems)
+
+여러 에이전트를 효과적으로 조율하는 것은 강력한 멀티 에이전트 시스템 구축의 핵심입니다. 웹 검색 에이전트와 코드 실행 에이전트 등 다양한 능력을 가진 에이전트를 조합해 더 정교한 솔루션을 만들 수 있습니다. 이 장에서는 멀티 에이전트 시스템의 설계, 구현, 관리 방법을 다룹니다.
+
+### 7️⃣ [비전 및 브라우저 에이전트(Vision and Browser agents)](./vision_agents)
+
+비전 에이전트는 **비전-언어 모델(VLM)**을 통합해 시각 정보를 처리·해석할 수 있습니다. 이 장에서는 VLM 기반 에이전트 설계·통합법, 이미지 기반 추론, 시각 데이터 분석, 멀티모달 상호작용 등을 다룹니다. 또한 비전 에이전트를 활용해 웹을 탐색하고 정보를 추출하는 브라우저 에이전트도 만들어봅니다.
+
+## 참고 자료
+
+- [smolagents 공식 문서](https://huggingface.co/docs/smolagents)
+- [효과적인 에이전트 만들기](https://www.anthropic.com/research/building-effective-agents) - 에이전트 아키텍처 연구 논문
+- [에이전트 가이드라인](https://huggingface.co/docs/smolagents/tutorials/building_good_agents) - 신뢰성 높은 에이전트 구축을 위한 베스트 프랙티스
+- [LangGraph Agents](https://langchain-ai.github.io/langgraph/) - 다양한 에이전트 구현 예시
+- [Function Calling Guide](https://platform.openai.com/docs/guides/function-calling) - LLM의 함수 호출 이해하기
+- [RAG 베스트 프랙티스](https://www.pinecone.io/learn/retrieval-augmented-generation/) - 효과적인 RAG 구현 가이드
diff --git a/units/ko/unit2/smolagents/multi_agent_systems.mdx b/units/ko/unit2/smolagents/multi_agent_systems.mdx
new file mode 100644
index 00000000..820c5479
--- /dev/null
+++ b/units/ko/unit2/smolagents/multi_agent_systems.mdx
@@ -0,0 +1,381 @@
+<CourseFloatingBanner 
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/#fileId=https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/multiagent_notebook.ipynb"},
+]}
+askForHelpUrl="http://hf.co/join/discord" />
+
+# 멀티 에이전트 시스템
+
+멀티 에이전트 시스템은 **특화된 에이전트들이 협력하여 복잡한 작업을 해결**할 수 있게 해주며, 모듈성, 확장성, 견고성을 높여줍니다. 단일 에이전트에 의존하는 대신, 각기 다른 능력을 가진 에이전트들이 작업을 분담합니다.
+
+**smolagents**에서는 다양한 에이전트를 결합해 파이썬 코드 생성, 외부 도구 호출, 웹 검색 등 다양한 작업을 수행할 수 있습니다. 이러한 에이전트들을 조율함으로써 강력한 워크플로우를 만들 수 있습니다.
+
+일반적인 구성 예시:
+- **매니저 에이전트**: 작업 분배 담당
+- **코드 인터프리터 에이전트**: 코드 실행 담당
+- **웹 검색 에이전트**: 정보 검색 담당
+
+아래 다이어그램은 **매니저 에이전트**가 **코드 인터프리터 도구**와 **웹 검색 에이전트**를 조율하는 간단한 멀티 에이전트 아키텍처를 보여줍니다. 웹 검색 에이전트는 `DuckDuckGoSearchTool`과 `VisitWebpageTool` 같은 도구를 활용해 정보를 수집합니다.
+
+<img src="https://mermaid.ink/img/pako:eNp1kc1qhTAQRl9FUiQb8wIpdNO76eKubrmFks1oRg3VSYgjpYjv3lFL_2hnMWQOJwn5sqgmelRWleUSKLAtFs09jqhtoWuYUFfFAa6QA9QDTnpzamheuhxn8pt40-6l13UtS0ddhtQXj6dbR4XUGQg6zEYasTF393KjeSDGnDJKNxzj8I_7hLW5IOSmP9CH9hv_NL-d94d4DVNg84p1EnK4qlIj5hGClySWbadT-6OdsrL02MI8sFOOVkciw8zx8kaNspxnrJQE0fXKtjBMMs3JA-MpgOQwftIE9Bzj14w-cMznI_39E9Z3p0uFoA?type=png" style='background: white;'>
+
+## 멀티 에이전트 시스템 실전 예시
+
+멀티 에이전트 시스템은 여러 특화 에이전트가 **오케스트레이터 에이전트**의 조율 아래 협력하는 구조입니다. 이 방식은 역할이 다른 에이전트들에게 작업을 분산시켜 복잡한 워크플로우를 구현할 수 있게 해줍니다.
+
+예를 들어, **멀티 에이전트 RAG 시스템**은 다음을 통합할 수 있습니다:
+- **웹 에이전트**: 인터넷 브라우징 담당
+- **리트리버 에이전트**: 지식 베이스 정보 검색 담당
+- **이미지 생성 에이전트**: 시각 자료 생성 담당
+
+이 모든 에이전트는 오케스트레이터가 작업 분배와 상호작용을 관리합니다.
+
+## 멀티 에이전트 계층 구조로 복잡한 문제 해결하기
+
+<Tip>
+<a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/multiagent_notebook.ipynb" target="_blank">이 노트북</a>을 따라가며 코드를 직접 실행해볼 수 있습니다.
+</Tip>
+
+리셉션이 다가오고 있습니다! 여러분의 도움으로 Alfred는 거의 모든 준비를 마쳤습니다.
+
+하지만 문제가 생겼습니다: 배트모빌이 사라졌습니다. Alfred는 대체 차량을 빨리 찾아야 합니다.
+
+다행히 브루스 웨인의 삶을 다룬 바이오픽 영화가 몇 편 제작되었으니, Alfred는 영화 세트장에 남겨진 차량을 찾아 현대식으로 개조할 수 있을지도 모릅니다. 물론 자율주행 기능도 필수겠죠.
+
+하지만 이 차량들은 전 세계 촬영지 어디에나 있을 수 있습니다.
+
+그래서 Alfred는 여러분의 도움이 필요합니다. 이 문제를 해결할 수 있는 에이전트를 만들어볼까요?
+
+> 👉 전 세계 배트맨 촬영지를 모두 찾아, 고담(40.7128° N, 74.0060° W)까지 화물선(비행기)으로 이동하는 데 걸리는 시간을 계산하고, 이를 지도에 표시하세요. 이동 시간에 따라 색상을 다르게 하고, 슈퍼카 공장도 같은 방식으로 표시하세요.
+
+함께 만들어봅시다!
+
+이 예시에는 추가 패키지가 필요하니 먼저 설치해 주세요:
+
+```bash
+pip install 'smolagents[litellm]' plotly geopandas shapely kaleido -q
+```
+
+### 먼저 화물기 이동 시간 계산 도구를 만듭니다.
+
+```python
+import math
+from typing import Optional, Tuple
+
+from smolagents import tool
+
+
+@tool
+def calculate_cargo_travel_time(
+    origin_coords: Tuple[float, float],
+    destination_coords: Tuple[float, float],
+    cruising_speed_kmh: Optional[float] = 750.0,  # 화물기 평균 속도
+) -> float:
+    """
+    두 지점(위도, 경도) 간 화물기 이동 시간을 대권거리로 계산합니다.
+
+    Args:
+        origin_coords: 출발지 (위도, 경도) 튜플
+        destination_coords: 도착지 (위도, 경도) 튜플
+        cruising_speed_kmh: 순항 속도(km/h, 기본값 750)
+
+    Returns:
+        float: 예상 이동 시간(시간 단위)
+
+    Example:
+        >>> # 시카고(41.8781° N, 87.6298° W) → 시드니(33.8688° S, 151.2093° E)
+        >>> result = calculate_cargo_travel_time((41.8781, -87.6298), (-33.8688, 151.2093))
+    """
+
+    def to_radians(degrees: float) -> float:
+        return degrees * (math.pi / 180)
+
+    # 좌표 변환
+    lat1, lon1 = map(to_radians, origin_coords)
+    lat2, lon2 = map(to_radians, destination_coords)
+
+    # 지구 반지름(km)
+    EARTH_RADIUS_KM = 6371.0
+
+    # haversine 공식으로 대권거리 계산
+    dlon = lon2 - lon1
+    dlat = lat2 - lat1
+
+    a = (
+        math.sin(dlat / 2) ** 2
+        + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
+    )
+    c = 2 * math.asin(math.sqrt(a))
+    distance = EARTH_RADIUS_KM * c
+
+    # 우회 경로, 관제 등 감안해 10% 추가
+    actual_distance = distance * 1.1
+
+    # 비행 시간 계산(이착륙 1시간 추가)
+    flight_time = (actual_distance / cruising_speed_kmh) + 1.0
+
+    return round(flight_time, 2)
+
+
+print(calculate_cargo_travel_time((41.8781, -87.6298), (-33.8688, 151.2093)))
+```
+
+### 에이전트 설정하기
+
+모델 제공자는 Together AI를 사용합니다. GoogleSearchTool은 [Serper API](https://serper.dev)를 사용하므로, 환경 변수 `SERPAPI_API_KEY`(provider="serpapi") 또는 `SERPER_API_KEY`(provider=serper)를 설정해야 합니다.
+
+Serp API가 없다면 `DuckDuckGoSearchTool`을 사용할 수 있지만, 속도 제한에 유의하세요.
+
+```python
+import os
+from PIL import Image
+from smolagents import CodeAgent, GoogleSearchTool, InferenceClientModel, VisitWebpageTool
+
+model = InferenceClientModel(model_id="Qwen/Qwen2.5-Coder-32B-Instruct", provider="together")
+```
+
+간단한 에이전트를 만들어 기본 리포트를 받아봅시다.
+
+```python
+task = """전 세계 배트맨 촬영지를 모두 찾아, 고담(40.7128° N, 74.0060° W)까지 화물기로 이동하는 시간을 계산해 pandas 데이터프레임으로 반환하세요. 슈퍼카 공장도 같은 방식으로 포함하세요."""
+```
+
+```python
+agent = CodeAgent(
+    model=model,
+    tools=[GoogleSearchTool("serper"), VisitWebpageTool(), calculate_cargo_travel_time],
+    additional_authorized_imports=["pandas"],
+    max_steps=20,
+)
+```
+
+```python
+result = agent.run(task)
+```
+
+```python
+result
+```
+
+실행 결과 예시:
+
+```python
+|  | Location                                             | Travel Time to Gotham (hours) |
+|--|------------------------------------------------------|------------------------------|
+| 0  | Necropolis Cemetery, Glasgow, Scotland, UK         | 8.60                         |
+| 1  | St. George's Hall, Liverpool, England, UK         | 8.81                         |
+| 2  | Two Temple Place, London, England, UK             | 9.17                         |
+| 3  | Wollaton Hall, Nottingham, England, UK           | 9.00                         |
+| 4  | Knebworth House, Knebworth, Hertfordshire, UK    | 9.15                         |
+| 5  | Acton Lane Power Station, Acton Lane, Acton, UK  | 9.16                         |
+| 6  | Queensboro Bridge, New York City, USA            | 1.01                         |
+| 7  | Wall Street, New York City, USA                  | 1.00                         |
+| 8  | Mehrangarh Fort, Jodhpur, Rajasthan, India       | 18.34                        |
+| 9  | Turda Gorge, Turda, Romania                      | 11.89                        |
+| 10 | Chicago, USA                                     | 2.68                         |
+| 11 | Hong Kong, China                                 | 19.99                        |
+| 12 | Cardington Studios, Northamptonshire, UK        | 9.10                         |
+| 13 | Warner Bros. Leavesden Studios, Hertfordshire, UK | 9.13                         |
+| 14 | Westwood, Los Angeles, CA, USA                  | 6.79                         |
+| 15 | Woking, UK (McLaren)                             | 9.13                         |
+```
+
+계획 단계(planning step)를 추가하고 프롬프트를 보강하면 더 나은 결과를 얻을 수 있습니다.
+
+계획 단계는 에이전트가 다음 단계를 미리 생각하고 계획할 수 있게 해줍니다.
+
+```python
+agent.planning_interval = 4
+
+detailed_report = agent.run(f"""
+여러분은 전문 분석가입니다. 여러 웹사이트를 방문해 종합 리포트를 작성합니다.
+for 루프를 활용해 여러 쿼리를 한 번에 검색하세요.
+각 데이터 포인트마다 소스 URL을 방문해 수치를 확인하세요.
+
+{task}
+""")
+
+print(detailed_report)
+```
+
+```python
+detailed_report
+```
+
+실행 결과 예시:
+
+```python
+|  | Location                                         | Travel Time (hours) |
+|--|--------------------------------------------------|---------------------|
+| 0  | Bridge of Sighs, Glasgow Necropolis, Glasgow, UK | 8.6                 |
+| 1  | Wishart Street, Glasgow, Scotland, UK         | 8.6                 |
+```
+
+이처럼 프롬프트와 계획 기능만으로도 훨씬 간결한 리포트를 얻을 수 있습니다!
+
+모델의 컨텍스트 윈도우가 빠르게 채워집니다. **따라서 상세 검색 결과와 다른 결과를 결합하도록 요청하면 느려지고 토큰·비용이 급증할 수 있습니다.**
+
+➡️ 시스템 구조를 개선해야 합니다.
+
+### ✌️ 두 에이전트로 작업 분할하기
+
+멀티 에이전트 구조는 서로 다른 하위 작업의 메모리를 분리해 두 가지 큰 이점을 제공합니다:
+- 각 에이전트가 핵심 작업에 집중해 성능이 향상됩니다.
+- 메모리 분리로 각 단계의 입력 토큰 수가 줄어, 지연과 비용이 감소합니다.
+
+웹 검색 전담 에이전트와 이를 관리하는 매니저 에이전트로 팀을 만들어봅시다.
+
+매니저 에이전트는 최종 리포트 작성을 위해 추가 import(`plotly`, `geopandas`, `shapely`)가 필요합니다.
+
+```python
+model = InferenceClientModel(
+    "Qwen/Qwen2.5-Coder-32B-Instruct", provider="together", max_tokens=8096
+)
+
+web_agent = CodeAgent(
+    model=model,
+    tools=[
+        GoogleSearchTool(provider="serper"),
+        VisitWebpageTool(),
+        calculate_cargo_travel_time,
+    ],
+    name="web_agent",
+    description="웹에서 정보를 찾는 역할",
+    verbosity_level=0,
+    max_steps=10,
+)
+```
+
+매니저 에이전트는 더 강력한 모델 [DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)을 사용하고, `planning_interval`도 추가합니다.
+
+```python
+from smolagents.utils import encode_image_base64, make_image_url
+from smolagents import OpenAIServerModel
+
+
+def check_reasoning_and_plot(final_answer, agent_memory):
+    multimodal_model = OpenAIServerModel("gpt-4o", max_tokens=8096)
+    filepath = "saved_map.png"
+    assert os.path.exists(filepath), "saved_map.png 파일이 저장되어야 합니다!"
+    image = Image.open(filepath)
+    prompt = (
+        f"다음은 사용자 요청과 에이전트 단계입니다: {agent_memory.get_succinct_steps()}. 아래는 생성된 지도입니다."
+        "추론 과정과 지도가 요청을 올바르게 해결하는지 확인하세요."
+        "먼저 이유를 나열한 뒤, 최종 결정(PASS/FAIL)을 작성하세요."
+        "너무 엄격할 필요는 없습니다. 대부분 해결했다면 PASS입니다."
+        "지도는 px.scatter_map으로 만들어야 PASS입니다."
+    )
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": prompt,
+                },
+                {
+                    "type": "image_url",
+                    "image_url": {"url": make_image_url(encode_image_base64(image))},
+                },
+            ],
+        }
+    ]
+    output = multimodal_model(messages).content
+    print("피드백: ", output)
+    if "FAIL" in output:
+        raise Exception(output)
+    return True
+
+
+manager_agent = CodeAgent(
+    model=InferenceClientModel("deepseek-ai/DeepSeek-R1", provider="together", max_tokens=8096),
+    tools=[calculate_cargo_travel_time],
+    managed_agents=[web_agent],
+    additional_authorized_imports=[
+        "geopandas",
+        "plotly",
+        "shapely",
+        "json",
+        "pandas",
+        "numpy",
+    ],
+    planning_interval=5,
+    verbosity_level=2,
+    final_answer_checks=[check_reasoning_and_plot],
+    max_steps=15,
+)
+```
+
+이 팀의 구조를 시각화해봅시다:
+
+```python
+manager_agent.visualize()
+```
+
+아래와 같이 구조와 도구 사용 관계를 한눈에 볼 수 있습니다:
+
+```python
+CodeAgent | deepseek-ai/DeepSeek-R1
+├── ✅ Authorized imports: ['geopandas', 'plotly', 'shapely', 'json', 'pandas', 'numpy']
+├── 🛠️ Tools:
+│   ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+│   ┃ Name                        ┃ Description                           ┃ Arguments                             ┃
+│   ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│   │ calculate_cargo_travel_time │ 두 지점 간 화물기 이동 시간 계산         │ origin_coords (`array`): 출발지 좌표   │
+│   │                             │                                       │ destination_coords (`array`): 도착지   │
+│   │                             │                                       │ cruising_speed_kmh (`number`): 속도    │
+│   │ final_answer                │ 문제에 대한 최종 답변 제공              │ answer (`any`): 최종 답변              │
+│   └─────────────────────────────┴───────────────────────────────────────┴───────────────────────────────────────┘
+└── 🤖 Managed agents:
+    └── web_agent | CodeAgent | Qwen/Qwen2.5-Coder-32B-Instruct
+        ├── ✅ Authorized imports: []
+        ├── 📝 Description: 웹에서 정보를 찾는 역할
+        └── 🛠️ Tools:
+            ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+            ┃ Name                        ┃ Description                       ┃ Arguments                         ┃
+            ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+            │ web_search                  │ 구글 웹 검색 수행                  │ query (`string`): 검색어           │
+            │                             │                                   │ filter_year (`integer`): 연도 제한 │
+            │ visit_webpage               │ 웹페이지 방문 및 내용 읽기         │ url (`string`): 방문할 URL         │
+            │ calculate_cargo_travel_time │ 두 지점 간 화물기 이동 시간 계산   │ origin_coords (`array`): 출발지     │
+            │                             │                                   │ destination_coords (`array`): 도착지│
+            │                             │                                   │ cruising_speed_kmh (`number`): 속도 │
+            │ final_answer                │ 문제에 대한 최종 답변 제공         │ answer (`any`): 최종 답변           │
+            └─────────────────────────────┴───────────────────────────────────┴───────────────────────────────────┘
+```
+
+```python
+manager_agent.run("""
+전 세계 배트맨 촬영지를 모두 찾아, 고담(40.7128° N, 74.0060° W)까지 화물기로 이동하는 시간을 계산하세요. 슈퍼카 공장도 같은 방식으로 포함해 총 6개 이상 지점을 지도에 산점도로 표시하고, 이동 시간에 따라 색상을 다르게 하세요. 결과 이미지는 saved_map.png로 저장하세요!
+
+지도 예시:
+import plotly.express as px
+df = px.data.carshare()
+fig = px.scatter_map(df, lat="centroid_lat", lon="centroid_lon", text="name", color="peak_hour", size=100,
+     color_continuous_scale=px.colors.sequential.Magma, size_max=15, zoom=1)
+fig.show()
+fig.write_image("saved_image.png")
+final_answer(fig)
+
+문자열을 코드로 처리하지 마세요. 문자열이 있으면 print로 출력하세요.
+""")
+```
+
+제 실행에서는 매니저 에이전트가 웹 에이전트에게 `1. 배트맨 촬영지 검색`, `2. 슈퍼카 공장 찾기`로 작업을 분배한 뒤, 결과를 집계해 지도를 그렸습니다.
+
+에이전트 상태에서 지도를 직접 확인해봅시다:
+
+```python
+manager_agent.python_executor.state["fig"]
+```
+
+아래와 같이 지도가 출력됩니다:
+
+![멀티에이전트 시스템 예시 출력 지도](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/smolagents/output_map.png)
+
+## 참고 자료
+
+- [멀티 에이전트 시스템](https://huggingface.co/docs/smolagents/main/en/examples/multiagents) – 멀티 에이전트 시스템 개요
+- [Agentic RAG란?](https://weaviate.io/blog/what-is-agentic-rag) – Agentic RAG 소개
+- [Multi-Agent RAG System 🤖🤝🤖 레시피](https://huggingface.co/learn/cookbook/multiagent_rag_system) – 단계별 구축 가이드
diff --git a/units/ko/unit2/smolagents/quiz1.mdx b/units/ko/unit2/smolagents/quiz1.mdx
new file mode 100644
index 00000000..a5ad07e4
--- /dev/null
+++ b/units/ko/unit2/smolagents/quiz1.mdx
@@ -0,0 +1,142 @@
+# 소규모 퀴즈(비채점) [[quiz1]]
+
+`smolagents`에 대한 이해도를 간단한 퀴즈로 확인해봅시다! 스스로 테스트해보면 학습 내용을 강화하고, 복습이 필요한 부분을 파악하는 데 도움이 됩니다.
+
+이 퀴즈는 선택 사항이며 점수화되지 않습니다.
+
+### Q1: `smolagents`를 다른 프레임워크보다 선택할 때의 주요 장점은 무엇인가요?
+다음 중 `smolagents` 접근 방식의 핵심 강점을 가장 잘 설명하는 문장은 무엇인가요?
+
+<Question
+choices={[
+  {
+    text: "전문 개발자만 사용할 수 있도록 고도로 특화된 설정 파일과 높은 학습 곡선을 사용한다",
+    explain: "smolagents는 단순함과 최소한의 코드 복잡성을 지향합니다. 학습 곡선이 높지 않습니다.",
+  },
+  {
+    text: "최소한의 추상화로 코드 우선 접근 방식을 지원하며, 에이전트가 파이썬 함수 호출을 통해 직접 상호작용할 수 있다",
+    explain: "네, smolagents는 단순하고 코드 중심의 설계를 강조합니다.",
+    correct: true
+  },
+  {
+    text: "JSON 기반 액션에 집중하여 에이전트가 코드를 작성할 필요가 없도록 한다",
+    explain: "smolagents는 JSON 기반 ToolCallingAgent도 지원하지만, CodeAgent의 코드 기반 접근을 더 강조합니다.",
+  },
+  {
+    text: "단일 LLM 제공자와 특수 하드웨어에만 깊이 통합된다",
+    explain: "smolagents는 다양한 모델 제공자를 지원하며, 특수 하드웨어가 필요하지 않습니다.",
+  }
+]}
+/>
+
+---
+
+### Q2: 어떤 상황에서 smolagents를 사용하는 것이 가장 적합할까요?
+다음 중 smolagents의 특성과 가장 잘 맞는 상황은 무엇인가요?
+
+<Question
+choices={[
+  {
+    text: "에이전트 로직을 빠르게 프로토타이핑하거나 실험하고 싶고, 애플리케이션이 비교적 단순한 경우",
+    explain: "네. smolagents는 간단하고 민첩한 에이전트 생성을 위해 설계되었습니다.",
+    correct: true
+  },
+  {
+    text: "수십 개의 마이크로서비스와 실시간 데이터 파이프라인이 필요한 대규모 엔터프라이즈 시스템 구축",
+    explain: "가능은 하지만, smolagents는 대규모 인프라보다는 경량 코드 중심 실험에 더 적합합니다.",
+  },
+  {
+    text: "클라우드 기반 LLM만 지원하고 로컬 추론을 금지하는 프레임워크가 필요한 경우",
+    explain: "smolagents는 로컬/호스팅 모델 모두 유연하게 통합할 수 있습니다.",
+  },
+  {
+    text: "고급 오케스트레이션, 멀티모달 인식, 엔터프라이즈급 기능이 기본 제공되는 시나리오",
+    explain: "고급 기능도 통합할 수 있지만, smolagents 자체는 경량·최소주의가 핵심입니다.",
+  }
+]}
+/>
+
+---
+
+### Q3: smolagents의 모델 통합 유연성에 대해 올바르게 설명한 것은?
+smolagents가 LLM과 상호작용하는 방식을 가장 잘 설명하는 문장을 고르세요.
+
+<Question
+choices={[
+  {
+    text: "내장 모델 하나만 제공하며, 커스텀 통합은 불가능하다",
+    explain: "smolagents는 다양한 백엔드와 사용자 정의 모델을 지원합니다.",
+  },
+  {
+    text: "LLM을 쓸 때마다 직접 모델 커넥터를 구현해야 한다",
+    explain: "여러 사전 구축된 커넥터가 있어 LLM 통합이 쉽습니다.",
+  },
+  {
+    text: "오픈소스 LLM만 통합할 수 있고, 상용 API는 지원하지 않는다",
+    explain: "smolagents는 오픈소스와 상용 모델 API 모두 통합할 수 있습니다.",
+  },
+  {
+    text: "다양한 LLM과 사용할 수 있으며, TransformersModel, InferenceClientModel, LiteLLMModel 등 미리 정의된 클래스를 제공한다",
+    explain: "정답입니다. smolagents는 다양한 클래스 기반의 유연한 모델 통합을 지원합니다.",
+    correct: true
+  }
+]}
+/>
+
+---
+
+### Q4: smolagents는 코드 기반 액션과 JSON 기반 액션에 대해 어떻게 접근하나요?
+다음 중 smolagents의 액션 포맷 철학을 올바르게 설명한 문장은?
+
+<Question
+choices={[
+  {
+    text: "모든 에이전트 작업에 JSON 기반 액션만 허용하며, 도구 호출을 추출하려면 파서가 필요하다",
+    explain: "ToolCallingAgent는 JSON 기반이지만, smolagents는 코드 기반 CodeAgent도 제공합니다.",
+  },
+  {
+    text: "CodeAgent를 통한 코드 기반 액션을 중심으로 하되, ToolCallingAgent로 JSON 기반 도구 호출도 지원한다",
+    explain: "정답입니다. smolagents는 코드 기반을 권장하지만, JSON 기반 대안도 제공합니다.",
+    correct: true
+  },
+  {
+    text: "외부 함수 호출을 모두 금지하고, 모든 로직이 LLM 내부에만 존재해야 한다",
+    explain: "smolagents는 LLM이 외부 도구나 코드를 호출할 수 있도록 설계되었습니다.",
+  },
+  {
+    text: "모든 코드 조각을 수동으로 JSON 객체로 변환해야 에이전트가 실행된다",
+    explain: "CodeAgent는 코드 조각을 자동으로 관리하므로 수동 변환이 필요 없습니다.",
+  }
+]}
+/>
+
+---
+
+### Q5: smolagents가 Hugging Face Hub와 통합되어 얻을 수 있는 이점은?
+Hub 통합의 핵심 장점을 올바르게 설명한 문장은?
+
+<Question
+choices={[
+  {
+    text: "모든 공개 모델을 상용 라이선스 등급으로 자동 업그레이드한다",
+    explain: "Hub 통합은 모델이나 도구의 라이선스 등급을 변경하지 않습니다.",
+  },
+  {
+    text: "로컬 추론을 완전히 비활성화하고, 원격 모델만 사용하도록 강제한다",
+    explain: "로컬 추론도 계속 사용할 수 있습니다. Hub에 올린다고 해서 로컬 사용이 막히지 않습니다.",
+  },
+  {
+    text: "에이전트나 도구를 업로드·공유해 다른 개발자가 쉽게 발견·재사용할 수 있다",
+    explain: "정답입니다. smolagents는 에이전트와 도구를 HF Hub에 업로드해 재사용할 수 있습니다.",
+    correct: true
+  },
+  {
+    text: "모든 코드 기반 에이전트를 영구 저장해, 업데이트나 버전 관리가 불가능하다",
+    explain: "Hub 저장소는 업데이트와 버전 관리가 가능하므로 언제든 수정할 수 있습니다.",
+  }
+]}
+/>
+
+---
+
+퀴즈를 모두 마쳤습니다! 🎉 틀린 문제가 있다면 *왜 smolagents를 사용할까* 섹션을 복습해보세요. 잘 풀었다면, 이제 smolagents의 더 고급 주제로 넘어갈 준비가 되었습니다!
diff --git a/units/ko/unit2/smolagents/quiz2.mdx b/units/ko/unit2/smolagents/quiz2.mdx
new file mode 100644
index 00000000..50794bcc
--- /dev/null
+++ b/units/ko/unit2/smolagents/quiz2.mdx
@@ -0,0 +1,142 @@
+# 소규모 퀴즈(비채점) [[quiz2]]
+
+*Code Agents*, *Tool Calling Agents*, *Tools* 섹션에 대한 이해도를 테스트해봅시다. 이 퀴즈는 선택 사항이며 점수화되지 않습니다.
+
+---
+
+### Q1: smolagents에서 `@tool` 데코레이터로 도구를 만드는 것과 `Tool` 서브클래스를 만드는 것의 핵심 차이는?
+두 방식의 도구 정의 차이를 가장 잘 설명하는 문장을 고르세요.
+
+<Question
+choices={[
+  {
+    text: "<code>@tool</code> 데코레이터는 리트리벌 기반 도구에만 필수이고, <code>Tool</code> 서브클래스는 텍스트 생성 작업에만 사용된다",
+    explain: "두 방식 모두 어떤 유형의 도구에도 사용할 수 있습니다.",
+  },
+  {
+    text: "<code>@tool</code> 데코레이터는 간단한 함수형 도구에 권장되고, <code>Tool</code> 서브클래스는 복잡한 기능이나 커스텀 메타데이터가 필요할 때 더 유연하다",
+    explain: "정답입니다. 데코레이터 방식이 더 간단하고, 서브클래싱은 맞춤 동작에 적합합니다.",
+    correct: true
+  },
+  {
+    text: "<code>@tool</code>은 멀티 에이전트 시스템에서만 쓸 수 있고, <code>Tool</code> 서브클래스는 단일 에이전트에만 쓸 수 있다",
+    explain: "모든 에이전트(단일/멀티)에서 두 방식 모두 사용할 수 있습니다.",
+  },
+  {
+    text: "<code>@tool</code>로 함수에 데코레이터를 달면 docstring이 필요 없고, 서브클래스는 docstring을 포함하면 안 된다",
+    explain: "두 방식 모두 명확한 docstring이 필요합니다.",
+  }
+]}
+/>
+
+---
+
+### Q2: CodeAgent는 ReAct(Reason + Act) 접근법으로 다단계 작업을 어떻게 처리하나요?
+CodeAgent가 일련의 단계를 실행해 문제를 푸는 방식을 올바르게 설명한 문장을 고르세요.
+
+<Question
+choices={[
+  {
+    text: "각 단계를 멀티 에이전트 시스템의 다른 에이전트에 넘기고, 결과를 합친다",
+    explain: "멀티 에이전트 시스템에서는 분산이 가능하지만, CodeAgent 자체도 ReAct로 여러 단계를 처리할 수 있습니다.",
+  },
+  {
+    text: "모든 액션을 JSON에 저장해 한 번에 실행한다",
+    explain: "이 방식은 ToolCallingAgent의 JSON 기반 접근에 가깝습니다.",
+  },
+  {
+    text: "내부 사고를 작성하고, 파이썬 코드를 생성·실행하며, 결과를 기록하는 과정을 반복해 최종 답에 도달한다",
+    explain: "정답입니다. CodeAgent는 ReAct 패턴(사고-행동-관찰-반복)으로 동작합니다.",
+    correct: true
+  },
+  {
+    text: "비전 모듈로 코드 출력을 검증한 뒤 다음 단계로 넘어간다",
+    explain: "비전 기능은 지원되지만, CodeAgent나 ReAct의 기본 요구사항은 아닙니다.",
+  }
+]}
+/>
+
+---
+
+### Q3: 도구를 Hugging Face Hub에 공유할 때의 주요 장점은?
+개발자가 커스텀 도구를 업로드·공유하는 가장 큰 이유를 고르세요.
+
+<Question
+choices={[
+  {
+    text: "도구가 자동으로 MultiStepAgent와 통합되어 RAG가 구현된다",
+    explain: "도구 공유는 자동으로 리트리벌이나 멀티스텝 로직을 설정하지 않습니다.",
+  },
+  {
+    text: "다른 사람이 내 도구를 쉽게 발견·재사용·통합할 수 있다",
+    explain: "정답입니다. Hub에 공유하면 누구나 빠르게 다운로드·재사용할 수 있습니다.",
+    correct: true
+  },
+  {
+    text: "CodeAgent만 도구를 호출할 수 있고, ToolCallingAgent는 불가능하다",
+    explain: "두 에이전트 모두 공유 도구를 호출할 수 있습니다.",
+  },
+  {
+    text: "도구가 자동으로 비전 기능을 갖춘 이미지 처리 함수로 변환된다",
+    explain: "도구 공유는 기능을 바꾸거나 비전 기능을 추가하지 않습니다.",
+  }
+]}
+/>
+
+---
+
+### Q4: ToolCallingAgent와 CodeAgent의 액션 실행 방식 차이에 대해 올바른 설명은?
+ToolCallingAgent의 동작 방식을 가장 잘 설명한 문장을 고르세요.
+
+<Question
+choices={[
+  {
+    text: "ToolCallingAgent는 멀티 에이전트 시스템에서만 쓸 수 있고, CodeAgent는 단독 실행이 가능하다",
+    explain: "두 에이전트 모두 단독 또는 멀티 시스템에서 사용할 수 있습니다.",
+  },
+  {
+    text: "ToolCallingAgent는 모든 추론을 리트리버 에이전트에 위임한 뒤 최종 답을 반환한다",
+    explain: "ToolCallingAgent도 메인 LLM이 추론을 담당합니다.",
+  },
+  {
+    text: "ToolCallingAgent는 도구 호출과 인자를 JSON으로 출력하고, 이를 파싱해 실행한다",
+    explain: "정답입니다. ToolCallingAgent는 JSON 방식으로 도구 호출을 정의합니다.",
+    correct: true
+  },
+  {
+    text: "ToolCallingAgent는 단일 단계 작업만 가능하며, 한 번 도구 호출 후 자동 종료된다",
+    explain: "ToolCallingAgent도 필요에 따라 여러 단계를 수행할 수 있습니다.",
+  }
+]}
+/>
+
+---
+
+### Q5: smolagents 기본 도구 상자에는 무엇이 포함되어 있고, 왜 사용할까요?
+기본 도구 상자의 목적과 내용을 가장 잘 설명한 문장을 고르세요.
+
+<Question
+choices={[
+  {
+    text: "DuckDuckGo 검색, PythonInterpreterTool, 최종 답변 도구 등 자주 쓰는 도구를 제공해 빠른 프로토타이핑이 가능하다",
+    explain: "정답입니다. 기본 도구 상자에는 바로 쓸 수 있는 도구들이 포함되어 있습니다.",
+    correct: true
+  },
+  {
+    text: "기본적으로 이미지 분류, OCR 등 비전 기반 작업만 지원한다",
+    explain: "비전 기능도 통합할 수 있지만, 기본 도구 상자는 비전 전용이 아닙니다.",
+  },
+  {
+    text: "멀티 에이전트 시스템 전용이며, 단일 CodeAgent와는 호환되지 않는다",
+    explain: "기본 도구 상자는 모든 에이전트 유형에서 사용할 수 있습니다.",
+  },
+  {
+    text: "대규모 벡터 스토어 기반 고급 RAG 기능을 자동 제공한다",
+    explain: "리트리벌 도구를 만들 수 있지만, 기본 상자에 고급 RAG 기능이 자동 포함되진 않습니다.",
+  }
+]}
+/>
+
+---
+
+퀴즈를 모두 마쳤습니다! 🎉 어려웠던 문제는 *Code Agents*, *Tool Calling Agents*, *Tools* 섹션을 복습해보세요. 모두 맞췄다면, robust한 smolagents 애플리케이션을 만들 준비가 된 것입니다!
diff --git a/units/ko/unit2/smolagents/retrieval_agents.mdx b/units/ko/unit2/smolagents/retrieval_agents.mdx
new file mode 100644
index 00000000..684538d6
--- /dev/null
+++ b/units/ko/unit2/smolagents/retrieval_agents.mdx
@@ -0,0 +1,168 @@
+<CourseFloatingBanner 
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/#fileId=https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/retrieval_agents.ipynb"},
+]}
+askForHelpUrl="http://hf.co/join/discord" />
+
+# 에이전틱 RAG 시스템 구축하기
+
+<Tip>
+코드는 <a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/retrieval_agents.ipynb" target="_blank">이 노트북</a>에서 따라할 수 있습니다. Google Colab에서 실행할 수 있습니다.
+</Tip>
+
+Retrieval Augmented Generation(RAG) 시스템은 데이터 검색과 생성 모델의 능력을 결합하여 상황에 맞는 답변을 제공합니다. 예를 들어, 사용자의 질문이 검색 엔진에 전달되고, 검색된 결과가 질문과 함께 모델에 제공됩니다. 모델은 질문과 검색된 정보를 바탕으로 답변을 생성합니다.
+
+에이전틱 RAG(검색 증강 생성)는 **자율 에이전트와 동적 지식 검색**을 결합하여 기존 RAG 시스템을 확장합니다.
+
+기존 RAG 시스템은 LLM이 검색된 데이터를 바탕으로 답변을 생성하지만, 에이전틱 RAG는 **검색과 생성 과정을 지능적으로 제어**하여 효율성과 정확성을 높입니다.
+
+기존 RAG 시스템의 주요 한계는 **단일 검색 단계에 의존**하고, 사용자의 질문과 직접적인 의미적 유사성에만 집중하여 관련 정보를 놓칠 수 있다는 점입니다.
+
+에이전틱 RAG는 에이전트가 검색 쿼리를 자율적으로 생성하고, 검색 결과를 비판적으로 평가하며, 여러 번의 검색 단계를 거쳐 더 맞춤화되고 포괄적인 출력을 생성할 수 있도록 합니다.
+
+## DuckDuckGo를 활용한 기본 검색
+
+이제 DuckDuckGo를 사용해 웹을 검색하는 간단한 에이전트를 만들어봅시다. 이 에이전트는 정보를 검색하고, 답변을 종합하여 질문에 답합니다. 에이전틱 RAG를 활용하면 Alfred의 에이전트는 다음과 같은 일을 할 수 있습니다:
+
+* 최신 슈퍼히어로 파티 트렌드 검색
+* 결과를 고급스러운 요소로 세분화
+* 정보를 종합하여 완성된 계획 제안
+
+Alfred의 에이전트가 이를 어떻게 수행하는지 살펴봅시다:
+
+```python
+from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel
+
+# 검색 도구 초기화
+search_tool = DuckDuckGoSearchTool()
+
+# 모델 초기화
+model = InferenceClientModel()
+
+agent = CodeAgent(
+    model=model,
+    tools=[search_tool],
+)
+
+# 예시 사용법
+response = agent.run(
+    "Search for luxury superhero-themed party ideas, including decorations, entertainment, and catering."
+)
+print(response)
+```
+
+에이전트의 동작 과정:
+
+1. **요청 분석:** Alfred의 에이전트는 쿼리의 핵심 요소(고급 슈퍼히어로 테마 파티, 장식, 엔터테인먼트, 케이터링 등)를 파악합니다.
+2. **검색 수행:** DuckDuckGo를 활용해 Alfred의 고급스러운 취향에 맞는 최신 정보를 검색합니다.
+3. **정보 종합:** 검색 결과를 바탕으로 파티의 모든 측면을 아우르는 실행 가능한 계획을 만듭니다.
+4. **정보 저장:** 검색된 정보를 저장해, 이후 파티 준비 시 효율적으로 재활용할 수 있습니다.
+
+## 맞춤형 지식 베이스 도구
+
+특정 작업에는 맞춤형 지식 베이스가 매우 유용합니다. 벡터 데이터베이스에 저장된 기술 문서나 전문 지식을 쿼리하는 도구를 만들어봅시다. 의미적 검색을 통해 Alfred의 요구에 가장 적합한 정보를 찾을 수 있습니다.
+
+벡터 데이터베이스는 텍스트나 기타 데이터를 머신러닝 모델로 임베딩(숫자 벡터)하여 저장합니다. 이를 통해 의미적으로 유사한 정보를 고차원 공간에서 찾을 수 있습니다.
+
+이 접근법은 사전 정의된 지식과 의미적 검색을 결합해 상황에 맞는 솔루션을 제공합니다. Alfred는 전문 지식에 접근해 파티의 모든 세부 사항을 완벽하게 준비할 수 있습니다.
+
+아래 예시에서는 BM25 검색기를 사용해 맞춤형 지식 베이스에서 파티 아이디어를 검색하는 도구를 만듭니다. `RecursiveCharacterTextSplitter`로 문서를 작은 청크로 나눠 검색 효율을 높입니다.
+
+```python
+from langchain.docstore.document import Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from smolagents import Tool
+from langchain_community.retrievers import BM25Retriever
+from smolagents import CodeAgent, InferenceClientModel
+
+class PartyPlanningRetrieverTool(Tool):
+    name = "party_planning_retriever"
+    description = "Alfred의 슈퍼히어로 테마 파티를 위한 아이디어를 의미적 검색으로 찾아줍니다."
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "파티 준비나 슈퍼히어로 테마와 관련된 쿼리입니다.",
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, docs, **kwargs):
+        super().__init__(**kwargs)
+        self.retriever = BM25Retriever.from_documents(
+            docs, k=5  # 상위 5개 문서 검색
+        )
+
+    def forward(self, query: str) -> str:
+        assert isinstance(query, str), "검색 쿼리는 문자열이어야 합니다."
+
+        docs = self.retriever.invoke(
+            query,
+        )
+        return "\n검색된 아이디어:\n" + "".join(
+            [
+                f"\n\n===== 아이디어 {str(i)} =====\n" + doc.page_content
+                for i, doc in enumerate(docs)
+            ]
+        )
+
+# 파티 준비에 관한 지식 베이스 예시
+party_ideas = [
+    {"text": "고급 장식(금색 장식, 벨벳 커튼 등)이 있는 슈퍼히어로 테마 가면무도회.", "source": "Party Ideas 1"},
+    {"text": "배트맨, 원더우먼 등 슈퍼히어로 테마 음악을 연주할 전문 DJ 고용.", "source": "Entertainment Ideas"},
+    {"text": "케이터링 메뉴에 슈퍼히어로 이름을 붙인 요리 제공(예: '헐크의 그린 스무디', '아이언맨의 파워 스테이크').", "source": "Catering Ideas"},
+    {"text": "장소 곳곳에 슈퍼히어로 로고와 고담 등 도시 프로젝션 장식.", "source": "Decoration Ideas"},
+    {"text": "VR을 활용한 슈퍼히어로 시뮬레이션, 테마 게임 등 인터랙티브 체험 제공.", "source": "Entertainment Ideas"}
+]
+
+source_docs = [
+    Document(page_content=doc["text"], metadata={"source": doc["source"]})
+    for doc in party_ideas
+]
+
+# 문서를 작은 청크로 분할
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size=500,
+    chunk_overlap=50,
+    add_start_index=True,
+    strip_whitespace=True,
+    separators=["\n\n", "\n", ".", " ", ""],
+)
+docs_processed = text_splitter.split_documents(source_docs)
+
+# 검색 도구 생성
+party_planning_retriever = PartyPlanningRetrieverTool(docs_processed)
+
+# 에이전트 초기화
+agent = CodeAgent(tools=[party_planning_retriever], model=InferenceClientModel())
+
+# 예시 사용법
+response = agent.run(
+    "Find ideas for a luxury superhero-themed party, including entertainment, catering, and decoration options."
+)
+
+print(response)
+```
+
+이 향상된 에이전트는 다음을 수행할 수 있습니다:
+1. 먼저 문서에서 관련 정보 검색
+2. 지식 베이스의 인사이트 결합
+3. 대화 맥락을 메모리에 유지
+
+## 고도화된 검색 기능
+
+에이전틱 RAG 시스템을 구축할 때, 에이전트는 다음과 같은 고급 전략을 사용할 수 있습니다:
+
+1. **쿼리 재구성(Query Reformulation):** 원본 쿼리 대신, 문서에 더 잘 맞는 최적화된 검색어 생성
+2. **쿼리 분해(Query Decomposition):** 여러 정보를 포함한 쿼리를 분해해 각각 검색
+3. **쿼리 확장(Query Expansion):** 쿼리를 다양한 표현으로 확장해 여러 방식으로 검색
+4. **재정렬(Reranking):** Cross-Encoder 등으로 검색 결과와 쿼리의 의미적 관련성 점수 부여
+5. **다단계 검색(Multi-Step Retrieval):** 초기 결과를 바탕으로 추가 검색 반복
+6. **소스 통합(Source Integration):** 웹 검색, 로컬 문서 등 다양한 소스 결합
+7. **결과 검증(Result Validation):** 검색된 내용의 적합성과 정확성 평가 후 답변에 포함
+
+효과적인 에이전틱 RAG 시스템을 위해서는 여러 측면을 신중히 고려해야 합니다. 에이전트는 **쿼리 유형과 맥락에 따라 적절한 도구를 선택**해야 하며, 메모리 시스템을 통해 대화 이력을 관리하고 중복 검색을 방지해야 합니다. 또한, 예비 전략을 마련해 주요 검색 방법이 실패해도 가치를 제공할 수 있어야 하며, 검증 단계를 통해 검색 결과의 정확성과 적합성을 보장해야 합니다.
+
+## 참고 자료
+
+- [Agentic RAG: turbocharge your RAG with query reformulation and self-query! 🚀](https://huggingface.co/learn/cookbook/agent_rag) - smolagents로 에이전틱 RAG 시스템을 개발하는 레시피
diff --git a/units/ko/unit2/smolagents/tool_calling_agents.mdx b/units/ko/unit2/smolagents/tool_calling_agents.mdx
new file mode 100644
index 00000000..3904eca4
--- /dev/null
+++ b/units/ko/unit2/smolagents/tool_calling_agents.mdx
@@ -0,0 +1,74 @@
+<CourseFloatingBanner 
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/#fileId=https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/tool_calling_agents.ipynb"},
+]}
+askForHelpUrl="http://hf.co/join/discord" />
+
+# 액션을 코드 스니펫 또는 JSON 블롭으로 작성하기
+
+<Tip>
+코드는 <a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/tool_calling_agents.ipynb" target="_blank">이 노트북</a>에서 따라할 수 있습니다. Google Colab에서 실행할 수 있습니다.
+</Tip>
+
+Tool Calling Agent는 `smolagents`에서 제공하는 두 번째 유형의 에이전트입니다. Python 코드를 실행하는 CodeAgent와 달리, **Tool Calling Agent는 LLM 제공업체의 내장 툴 콜링 기능**을 활용해 **JSON 구조**로 툴 호출을 생성합니다. 이는 OpenAI, Anthropic 등 많은 제공업체에서 사용하는 표준 방식입니다.
+
+예를 들어, Alfred가 케이터링 서비스와 파티 아이디어를 검색하고 싶을 때, `CodeAgent`는 다음과 같이 Python 코드를 생성해 실행합니다:
+
+```python
+for query in [
+    "Best catering services in Gotham City", 
+    "Party theme ideas for superheroes"
+]:
+    print(web_search(f"Search for: {query}"))
+```
+
+`ToolCallingAgent`는 대신 JSON 구조를 생성합니다:
+
+```python
+[
+    {"name": "web_search", "arguments": "Best catering services in Gotham City"},
+    {"name": "web_search", "arguments": "Party theme ideas for superheroes"}
+]
+```
+
+이 JSON 블롭이 시스템에 전달되어 툴 호출이 실행됩니다.
+
+`smolagents`는 [CodeAgent가 전반적으로 더 좋은 성능을 보이기 때문에](https://huggingface.co/papers/2402.01030) 주로 CodeAgent에 초점을 맞추지만, ToolCallingAgent는 변수 처리나 복잡한 툴 호출이 필요 없는 간단한 시스템에 효과적입니다.
+
+![Code vs JSON Actions](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/code_vs_json_actions.png)  
+
+## Tool Calling Agent는 어떻게 동작하나요?  
+
+Tool Calling Agent는 CodeAgent와 동일한 다단계 워크플로우를 따릅니다([이전 섹션](./code_agents) 참고). 
+
+핵심 차이점은 **액션을 구조화하는 방식**입니다. ToolCallingAgent는 실행 가능한 코드 대신, **툴 이름과 인자를 명시한 JSON 객체**를 생성합니다. 시스템은 이 명령을 파싱해 적절한 툴을 실행합니다.
+
+## 예시: Tool Calling Agent 실행하기  
+
+앞서 Alfred가 파티 준비를 시작했던 예시를 ToolCallingAgent로 다시 구현해보겠습니다. DuckDuckGo를 활용해 웹을 검색하는 에이전트를 만들지만, 에이전트 타입만 다르고 나머지는 프레임워크가 처리합니다:
+
+```python
+from smolagents import ToolCallingAgent, DuckDuckGoSearchTool, InferenceClientModel
+
+agent = ToolCallingAgent(tools=[DuckDuckGoSearchTool()], model=InferenceClientModel())
+
+agent.run("Search for the best music recommendations for a party at the Wayne's mansion.")
+```
+
+에이전트의 실행 로그를 보면, `Executing parsed code:` 대신 다음과 같은 메시지가 출력됩니다:
+
+```text
+╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ Calling tool: 'web_search' with arguments: {'query': "best music recommendations for a party at Wayne's         │
+│ mansion"}                                                                                                       │
+╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
+```
+
+에이전트는 구조화된 툴 호출을 생성하고, 시스템이 이를 처리해 결과를 반환합니다. CodeAgent처럼 코드를 직접 실행하지 않습니다.
+
+이제 두 에이전트 타입의 차이를 이해했으니, 필요에 따라 적합한 방식을 선택할 수 있습니다. Alfred의 파티 준비를 계속 이어가봅시다! 🎉
+
+## 참고 자료
+
+- [ToolCallingAgent 공식 문서](https://huggingface.co/docs/smolagents/v1.8.1/en/reference/agents#smolagents.ToolCallingAgent) - ToolCallingAgent에 대한 공식 문서
diff --git a/units/ko/unit2/smolagents/tools.mdx b/units/ko/unit2/smolagents/tools.mdx
new file mode 100644
index 00000000..893bdbcf
--- /dev/null
+++ b/units/ko/unit2/smolagents/tools.mdx
@@ -0,0 +1,295 @@
+<CourseFloatingBanner 
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/#fileId=https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/tools.ipynb"},
+]} 
+askForHelpUrl="http://hf.co/join/discord" />
+
+# 도구 (Tools)
+
+[unit 1](https://huggingface.co/learn/agents-course/unit1/tools)에서 살펴본 것처럼, 에이전트는 다양한 작업을 수행하기 위해 도구를 사용합니다. `smolagents`에서 도구는 **에이전트 시스템 내에서 LLM이 호출할 수 있는 함수**로 취급됩니다.
+
+도구와 상호작용하려면 LLM이 다음과 같은 **인터페이스 설명**을 필요로 합니다:
+
+- **이름**: 도구의 이름
+- **도구 설명**: 도구가 수행하는 작업
+- **입력 타입 및 설명**: 도구가 받는 인자
+- **출력 타입**: 도구가 반환하는 값
+
+예를 들어, Alfred가 Wayne Manor에서 파티를 준비할 때, 케이터링 서비스 검색부터 파티 테마 아이디어 찾기까지 다양한 정보를 수집해야 합니다. 아래는 간단한 검색 도구 인터페이스 예시입니다:
+
+- **이름:** `web_search`
+- **도구 설명:** 특정 쿼리로 웹을 검색합니다
+- **입력:** `query` (string) - 검색어
+- **출력:** 검색 결과가 담긴 문자열
+
+이러한 도구를 사용하면 Alfred는 완벽한 파티 준비를 위해 필요한 모든 정보를 쉽게 모을 수 있습니다.
+
+아래 애니메이션은 도구 호출이 어떻게 관리되는지 보여줍니다:
+
+![Agentic pipeline from https://huggingface.co/docs/smolagents/conceptual_guides/react](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/Agent_ManimCE.gif)
+
+## 도구 생성 방법
+
+`smolagents`에서 도구는 두 가지 방식으로 정의할 수 있습니다:
+1. **`@tool` 데코레이터**를 사용한 간단한 함수형 도구
+2. **`Tool` 클래스를 상속한 복잡한 도구**
+
+### `@tool` 데코레이터
+
+`@tool` 데코레이터는 **간단한 도구를 정의할 때 권장되는 방법**입니다. 내부적으로 smolagents는 함수에서 기본 정보를 파싱합니다. 함수 이름을 명확하게 짓고, 좋은 docstring을 작성하면 LLM이 더 쉽게 사용할 수 있습니다.
+
+이 방식에서는 다음을 지켜야 합니다:
+- **명확하고 설명적인 함수명**
+- **입력과 출력에 타입 힌트 사용**
+- **자세한 설명과 Args 섹션**
+
+#### 고평점 케이터링 도구 예시
+
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit2/smolagents/alfred-catering.jpg" alt="Alfred Catering"/>
+
+<Tip>
+코드는 <a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/tools.ipynb" target="_blank">이 노트북</a>에서 따라할 수 있습니다. Google Colab에서 실행할 수 있습니다.
+</Tip>
+
+Alfred가 파티 메뉴를 정했다면, 많은 손님을 위해 케이터링 서비스를 고용해야 합니다. Gotham에서 평점이 가장 높은 케이터링 서비스를 찾는 도구를 만들어봅시다.
+
+```python
+from smolagents import CodeAgent, InferenceClientModel, tool
+
+# Gotham에서 평점이 가장 높은 케이터링 서비스를 반환하는 함수 예시
+@tool
+def catering_service_tool(query: str) -> str:
+    """
+    이 도구는 Gotham City에서 평점이 가장 높은 케이터링 서비스를 반환합니다.
+
+    Args:
+        query: 케이터링 서비스를 찾기 위한 검색어
+    """
+    # 예시 케이터링 서비스와 평점
+    services = {
+        "Gotham Catering Co.": 4.9,
+        "Wayne Manor Catering": 4.8,
+        "Gotham City Events": 4.7,
+    }
+
+    # 평점이 가장 높은 서비스 찾기(검색어 필터링은 생략)
+    best_service = max(services, key=services.get)
+
+    return best_service
+
+
+agent = CodeAgent(tools=[catering_service_tool], model=InferenceClientModel())
+
+# 에이전트 실행 예시
+result = agent.run(
+    "Can you give me the name of the highest-rated catering service in Gotham City?"
+)
+
+print(result)   # 출력: Gotham Catering Co.
+```
+
+### Python 클래스로 도구 정의하기
+
+이 방식은 [`Tool`](https://huggingface.co/docs/smolagents/v1.8.1/en/reference/tools#smolagents.Tool) 클래스를 상속해 복잡한 도구를 만드는 방법입니다. 클래스는 함수에 메타데이터를 추가해 LLM이 효과적으로 사용할 수 있도록 도와줍니다. 이 클래스에서는 다음을 정의합니다:
+
+- `name`: 도구 이름
+- `description`: 시스템 프롬프트에 들어갈 설명
+- `inputs`: 입력 타입과 설명이 담긴 딕셔너리
+- `output_type`: 반환 타입
+- `forward`: 실제 동작을 수행하는 메서드
+
+아래는 `Tool`을 상속해 슈퍼히어로 테마 파티 아이디어를 생성하는 도구 예시입니다.
+
+#### 슈퍼히어로 테마 파티 아이디어 생성 도구
+
+Alfred는 Wayne Manor에서 슈퍼히어로 테마 파티를 준비합니다. 손님들을 놀라게 할 독특한 테마가 필요합니다. 아래 도구는 카테고리에 따라 창의적인 파티 아이디어를 제안합니다.
+
+```python
+from smolagents import Tool, CodeAgent, InferenceClientModel
+
+class SuperheroPartyThemeTool(Tool):
+    name = "superhero_party_theme_generator"
+    description = """
+    이 도구는 카테고리에 따라 창의적인 슈퍼히어로 테마 파티 아이디어를 제안합니다.
+    고유한 파티 테마 아이디어를 반환합니다."""
+
+    inputs = {
+        "category": {
+            "type": "string",
+            "description": "슈퍼히어로 파티 유형(예: 'classic heroes', 'villain masquerade', 'futuristic Gotham')",
+        }
+    }
+
+    output_type = "string"
+
+    def forward(self, category: str):
+        themes = {
+            "classic heroes": "Justice League Gala: 손님들이 DC 영웅으로 분장하고, 'The Kryptonite Punch' 같은 테마 칵테일 제공.",
+            "villain masquerade": "Gotham Rogues' Ball: 손님들이 배트맨 빌런으로 분장하는 미스터리 가면무도회.",
+            "futuristic Gotham": "Neo-Gotham Night: 배트맨 비욘드에서 영감을 받은 사이버펑크 스타일 파티, 네온 장식과 미래형 소품.",
+        }
+
+        return themes.get(category.lower(), "테마를 찾을 수 없습니다. 'classic heroes', 'villain masquerade', 'futuristic Gotham' 중에서 선택해보세요.")
+
+# 도구 인스턴스화
+party_theme_tool = SuperheroPartyThemeTool()
+agent = CodeAgent(tools=[party_theme_tool], model=InferenceClientModel())
+
+# 에이전트 실행 예시
+result = agent.run(
+    "What would be a good superhero party idea for a 'villain masquerade' theme?"
+)
+
+print(result)  # 출력: "Gotham Rogues' Ball: 손님들이 배트맨 빌런으로 분장하는 미스터리 가면무도회."
+```
+
+이 도구로 Alfred는 슈퍼히어로 테마 파티의 완벽한 호스트가 될 수 있습니다! 🦸‍♂️🦸‍♀️
+
+## 기본 도구 모음(Default Toolbox)
+
+`smolagents`에는 바로 사용할 수 있는 여러 기본 도구가 포함되어 있습니다. [기본 도구 모음](https://huggingface.co/docs/smolagents/guided_tour?build-a-tool=Decorate+a+function+with+%40tool#default-toolbox)에는 다음이 포함됩니다:
+
+- **PythonInterpreterTool**
+- **FinalAnswerTool**
+- **UserInputTool**
+- **DuckDuckGoSearchTool**
+- **GoogleSearchTool**
+- **VisitWebpageTool**
+
+Alfred는 다음과 같이 다양한 도구를 활용해 Wayne Manor에서 완벽한 파티를 준비할 수 있습니다:
+
+- `DuckDuckGoSearchTool`로 창의적인 슈퍼히어로 테마 파티 아이디어 검색
+- `GoogleSearchTool`로 Gotham에서 평점이 가장 높은 케이터링 서비스 찾기
+- `PythonInterpreterTool`로 좌석 배치 계산
+- 모든 정보를 모아 `FinalAnswerTool`로 계획 정리
+
+이 도구들로 Alfred는 완벽하고 매끄러운 파티를 보장할 수 있습니다. 🦇💡
+
+## 도구 공유 및 가져오기
+
+**smolagents**의 강력한 기능 중 하나는 커스텀 도구를 Hub에 공유하고, 커뮤니티에서 만든 도구를 쉽게 가져올 수 있다는 점입니다. 여기에는 **HF Spaces** 및 **LangChain 도구**와의 연동도 포함되어, Alfred가 Wayne Manor에서 잊지 못할 파티를 기획하는 데 큰 도움이 됩니다. 🎭
+
+이러한 통합을 통해 Alfred는 고급 이벤트 플래닝 도구를 활용할 수 있습니다. 예를 들어, 조명 조정, 파티 음악 추천, 케이터링 업체와의 협업 등 다양한 작업을 자동화할 수 있습니다.
+
+아래는 이러한 기능이 파티 경험을 어떻게 향상시키는지 보여주는 예시입니다:
+
+### 도구를 Hub에 공유하기
+
+커스텀 도구를 커뮤니티에 공유하는 것은 매우 쉽습니다! `push_to_hub()` 메서드를 사용해 Hugging Face 계정에 업로드하면 됩니다.
+
+예를 들어, Alfred는 자신의 `party_theme_tool`을 공유해 다른 사람들도 Gotham 최고의 케이터링 서비스를 찾을 수 있도록 도울 수 있습니다:
+
+```python
+party_theme_tool.push_to_hub("{your_username}/party_theme_tool", token="<YOUR_HUGGINGFACEHUB_API_TOKEN>")
+```
+
+### Hub에서 도구 가져오기
+
+다른 사용자가 만든 도구를 `load_tool()` 함수로 쉽게 가져올 수 있습니다. 예를 들어, Alfred가 AI로 파티 홍보 이미지를 만들고 싶다면, 커뮤니티에서 미리 만들어진 도구를 활용할 수 있습니다:
+
+```python
+from smolagents import load_tool, CodeAgent, InferenceClientModel
+
+image_generation_tool = load_tool(
+    "m-ric/text-to-image",
+    trust_remote_code=True
+)
+
+agent = CodeAgent(
+    tools=[image_generation_tool],
+    model=InferenceClientModel()
+)
+
+agent.run("Generate an image of a luxurious superhero-themed party at Wayne Manor with made-up superheros.")
+```
+
+### HF Space를 도구로 가져오기
+
+`Tool.from_space()`를 사용해 HF Space를 도구로 가져올 수도 있습니다. 이를 통해 커뮤니티의 수천 개 Space와 연동해 이미지 생성, 데이터 분석 등 다양한 작업을 수행할 수 있습니다.
+
+이 도구는 `gradio_client`를 통해 Space의 Gradio 백엔드와 연결되므로, 미리 pip로 설치해야 합니다.
+
+파티를 위해 Alfred는 AI로 생성한 이미지를 파티 공지에 활용할 수 있습니다. 아래는 그 예시입니다:
+
+```python
+from smolagents import CodeAgent, InferenceClientModel, Tool
+
+image_generation_tool = Tool.from_space(
+    "black-forest-labs/FLUX.1-schnell",
+    name="image_generator",
+    description="Generate an image from a prompt"
+)
+
+model = InferenceClientModel("Qwen/Qwen2.5-Coder-32B-Instruct")
+
+agent = CodeAgent(tools=[image_generation_tool], model=model)
+
+agent.run(
+    "Improve this prompt, then generate an image of it.",
+    additional_args={'user_prompt': 'A grand superhero-themed party at Wayne Manor, with Alfred overseeing a luxurious gala'}
+)
+```
+
+### LangChain 도구 가져오기
+
+`LangChain` 프레임워크는 이후 섹션에서 자세히 다룹니다. 여기서는 smolagents 워크플로우에서 LangChain 도구를 재사용할 수 있다는 점만 알아둡시다!
+
+`Tool.from_langchain()` 메서드로 LangChain 도구를 쉽게 불러올 수 있습니다. Alfred는 Wayne Manor에서 최고의 엔터테인먼트 아이디어를 찾기 위해 LangChain 도구를 활용할 수 있습니다.
+
+```python
+from langchain.agents import load_tools
+from smolagents import CodeAgent, InferenceClientModel, Tool
+
+search_tool = Tool.from_langchain(load_tools(["serpapi"])[0])
+
+agent = CodeAgent(tools=[search_tool], model=model)
+
+agent.run("Search for luxury entertainment ideas for a superhero-themed event, such as live performances and interactive experiences.")
+```
+
+### MCP 서버에서 도구 모음 가져오기
+
+`smolagents`는 [glama.ai](https://glama.ai/mcp/servers) 또는 [smithery.ai](https://smithery.ai)에서 제공하는 수백 개 MCP 서버의 도구도 가져올 수 있습니다. MCP에 대해 더 알고 싶다면 [무료 MCP 강의](https://huggingface.co/learn/mcp-course/)를 참고하세요.
+
+<details>
+<summary>mcp 클라이언트 설치</summary>
+
+먼저 `smolagents`의 mcp 통합을 설치해야 합니다.
+
+```bash
+pip install "smolagents[mcp]"
+```
+</details>
+
+MCP 서버의 도구는 ToolCollection 객체로 불러올 수 있습니다:
+
+```python
+import os
+from smolagents import ToolCollection, CodeAgent
+from mcp import StdioServerParameters
+from smolagents import InferenceClientModel
+
+
+model = InferenceClientModel("Qwen/Qwen2.5-Coder-32B-Instruct")
+
+
+server_parameters = StdioServerParameters(
+    command="uvx",
+    args=["--quiet", "pubmedmcp@0.1.3"],
+    env={"UV_PYTHON": "3.12", **os.environ},
+)
+
+with ToolCollection.from_mcp(server_parameters, trust_remote_code=True) as tool_collection:
+    agent = CodeAgent(tools=[*tool_collection.tools], model=model, add_base_tools=True)
+    agent.run("Please find a remedy for hangover.")
+```
+
+이렇게 하면 Alfred는 고급 엔터테인먼트 옵션을 빠르게 찾을 수 있어, Gotham의 명사들이 잊지 못할 슈퍼히어로 파티를 즐길 수 있습니다! 🎉
+
+## 참고 자료
+
+- [Tools Tutorial](https://huggingface.co/docs/smolagents/tutorials/tools) - 도구 사용법을 익힐 수 있는 튜토리얼
+- [Tools Documentation](https://huggingface.co/docs/smolagents/v1.8.1/en/reference/tools) - 도구에 대한 공식 문서
+- [Tools Guided Tour](https://huggingface.co/docs/smolagents/v1.8.1/en/guided_tour#tools) - 도구를 효율적으로 만들고 활용하는 단계별 가이드
+- [Building Effective Agents](https://huggingface.co/docs/smolagents/tutorials/building_good_agents) - 신뢰성 높고 성능 좋은 커스텀 함수 에이전트 개발 가이드
diff --git a/units/ko/unit2/smolagents/vision_agents.mdx b/units/ko/unit2/smolagents/vision_agents.mdx
new file mode 100644
index 00000000..fb9a6b84
--- /dev/null
+++ b/units/ko/unit2/smolagents/vision_agents.mdx
@@ -0,0 +1,224 @@
+<CourseFloatingBanner 
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/#fileId=https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/vision_agents.ipynb"},
+]}
+askForHelpUrl="http://hf.co/join/discord" />
+
+# smolagents로 비전 에이전트 만들기
+
+<Tip warning={true}>
+이 섹션의 예제는 강력한 VLM(비전-언어 모델) API가 필요합니다. 우리는 GPT-4o API로 테스트했습니다.  
+하지만 <a href="./why_use_smolagents">Why use smolagents</a>에서는 smolagents와 Hugging Face에서 지원하는 대체 솔루션도 다루고 있습니다. 다른 옵션을 탐색하고 싶다면 해당 섹션을 참고하세요.
+</Tip>
+
+에이전트에 시각적 능력을 부여하는 것은 텍스트 처리 이상의 실제 문제를 해결하는 데 매우 중요합니다. 웹 브라우징이나 문서 이해 등 많은 실제 과제는 풍부한 시각 정보를 분석해야 합니다. 다행히도, `smolagents`는 비전-언어 모델(VLM)을 내장 지원하여 에이전트가 이미지를 효과적으로 처리하고 해석할 수 있게 해줍니다.  
+
+이 예시에서, Wayne Manor의 집사 Alfred는 파티에 참석하는 손님들의 신원을 확인하는 임무를 맡았습니다. Alfred는 모든 손님을 알지 못할 수 있으므로, 손님의 외모에 대한 시각 정보를 검색해 신원을 확인하는 에이전트를 사용할 수 있습니다. 이를 통해 Alfred는 입장 허가 여부를 현명하게 결정할 수 있습니다. 예시를 함께 만들어봅시다!
+
+
+## 에이전트 실행 시작 시 이미지 제공하기
+
+<Tip>
+코드는 <a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/vision_agents.ipynb" target="_blank">이 노트북</a>에서 따라할 수 있습니다. Google Colab에서 실행할 수 있습니다.
+</Tip>
+
+이 방식에서는 이미지를 에이전트 실행 시점에 `task_images`로 전달합니다. 에이전트는 이 이미지를 전체 실행 과정에서 활용합니다.  
+
+예를 들어, Alfred는 이전 파티에서 손님들의 이름과 함께 저장된 이미지 데이터셋을 가지고 있습니다. 새로운 방문객의 이미지를 받아, 기존 데이터셋과 비교해 입장 허가 여부를 결정할 수 있습니다.  
+
+이번에는 한 손님이 입장하려고 하는데, Alfred는 이 손님이 Wonder Woman으로 위장한 Joker일 수 있다고 의심합니다. Alfred는 신원을 확인해 원치 않는 인물이 입장하지 못하도록 해야 합니다.  
+
+예시를 만들어봅시다. 우선 이미지를 불러옵니다. 여기서는 위키피디아 이미지를 사용하지만, 실제로는 다양한 활용이 가능합니다!
+
+```python
+from PIL import Image
+import requests
+from io import BytesIO
+
+image_urls = [
+    "https://upload.wikimedia.org/wikipedia/commons/e/e8/The_Joker_at_Wax_Museum_Plus.jpg", # Joker 이미지
+    "https://upload.wikimedia.org/wikipedia/en/9/98/Joker_%28DC_Comics_character%29.jpg" # Joker 이미지
+]
+
+images = []
+for url in image_urls:
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36" 
+    }
+    response = requests.get(url,headers=headers)
+    image = Image.open(BytesIO(response.content)).convert("RGB")
+    images.append(image)
+```
+
+이제 이미지를 준비했으니, 에이전트가 손님이 Wonder Woman인지 Joker인지 판별해줍니다.
+
+```python
+from smolagents import CodeAgent, OpenAIServerModel
+
+model = OpenAIServerModel(model_id="gpt-4o")
+
+# 에이전트 인스턴스화
+agent = CodeAgent(
+    tools=[],
+    model=model,
+    max_steps=20,
+    verbosity_level=2
+)
+
+response = agent.run(
+    """
+    이 사진 속 만화 캐릭터의 의상과 메이크업을 묘사해 주세요.
+    손님이 The Joker인지 Wonder Woman인지 알려주세요.
+    """,
+    images=images
+)
+```
+
+실행 결과는 다음과 같습니다(실행 환경에 따라 다를 수 있습니다):
+
+```python
+    {
+        'Costume and Makeup - First Image': (
+            '보라색 코트와 노란색 셔츠 위에 보라색 실크 크라바트 또는 타이.',
+            '흰색 얼굴 분장, 과장된 이목구비, 진한 눈썹, 파란 아이섀도, 빨간 입술로 넓은 미소.'
+        ),
+        'Costume and Makeup - Second Image': (
+            '꽃이 달린 어두운 정장, 손에 트럼프 카드를 들고 있음.',
+            '창백한 피부, 초록색 머리, 과장된 미소의 빨간 입술.'
+        ),
+        'Character Identity': '이 캐릭터는 만화에서 묘사된 The Joker와 유사합니다.'
+    }
+```
+
+이처럼, 결과를 통해 손님이 다른 인물로 위장했음을 알 수 있으므로, Alfred는 Joker의 입장을 막을 수 있습니다!
+
+## 동적 검색으로 이미지 제공하기
+
+<Tip>
+코드는 <a href="https://huggingface.co/agents-course/notebooks/blob/main/unit2/smolagents/vision_web_browser.py" target="_blank">이 Python 파일</a>에서 따라할 수 있습니다.
+</Tip>
+
+이전 방식도 유용하지만, 데이터베이스에 손님이 없는 경우에는 외부에서 이미지를 동적으로 검색해야 할 수 있습니다. 예를 들어, 웹을 탐색하며 손님에 대한 이미지를 찾아 신원을 확인하는 방식입니다.
+
+이 방식에서는 에이전트 실행 중에 이미지를 동적으로 메모리에 추가합니다. smolagents의 에이전트는 `MultiStepAgent` 클래스를 기반으로 하며, 이는 ReAct 프레임워크의 추상화입니다. 이 클래스는 다양한 변수와 지식을 여러 단계에 걸쳐 기록하는 구조적 사이클로 동작합니다:
+
+1. **SystemPromptStep:** 시스템 프롬프트 저장
+2. **TaskStep:** 사용자 쿼리 및 입력 기록
+3. **ActionStep:** 에이전트의 액션 및 결과 로그 기록
+
+이 구조적 접근법 덕분에, 에이전트는 시각 정보를 동적으로 통합하고, 변화하는 작업에 적응적으로 대응할 수 있습니다. 아래 다이어그램은 이러한 동적 워크플로우와 각 단계가 에이전트 라이프사이클에서 어떻게 통합되는지 보여줍니다. 브라우징 중에는 에이전트가 스크린샷을 찍어 `observation_images`에 저장할 수 있습니다.
+
+![Dynamic image retrieval](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/blog/smolagents-can-see/diagram_adding_vlms_smolagents.png)
+
+이제 필요성을 이해했으니, 전체 예시를 만들어봅시다. 이번에는 Alfred가 손님 신원 확인 과정을 완전히 통제하고 싶어 하므로, 웹을 탐색하며 정보를 찾는 것이 적합합니다. 이를 위해 Selenium과 Helium 등 브라우저 자동화 도구가 필요합니다. 아래 명령어로 필요한 패키지를 설치하세요:
+
+```bash
+pip install "smolagents[all]" helium selenium python-dotenv
+```
+
+에이전트에는 웹 브라우징을 위한 `search_item_ctrl_f`, `go_back`, `close_popups` 등 도구가 필요합니다. 이 도구들은 실제 사용자가 웹을 탐색하는 것처럼 동작하게 해줍니다.
+
+```python
+@tool
+def search_item_ctrl_f(text: str, nth_result: int = 1) -> str:
+    """
+    현재 페이지에서 Ctrl + F로 텍스트를 검색하고 n번째 결과로 이동합니다.
+    Args:
+        text: 검색할 텍스트
+        nth_result: 몇 번째 결과로 이동할지(기본값: 1)
+    """
+    elements = driver.find_elements(By.XPATH, f"//*[contains(text(), '{text}')]")
+    if nth_result > len(elements):
+        raise Exception(f"{nth_result}번째 결과를 찾을 수 없습니다. (총 {len(elements)}개 일치)")
+    result = f"'{text}'에 대해 {len(elements)}개 일치."
+    elem = elements[nth_result - 1]
+    driver.execute_script("arguments[0].scrollIntoView(true);", elem)
+    result += f"{len(elements)}개 중 {nth_result}번째 요소로 포커스 이동"
+    return result
+
+
+@tool
+def go_back() -> None:
+    """이전 페이지로 이동합니다."""
+    driver.back()
+
+
+@tool
+def close_popups() -> str:
+    """
+    페이지의 모달 또는 팝업을 닫습니다. 팝업 창을 닫을 때 사용하세요! 쿠키 배너에는 동작하지 않습니다.
+    """
+    webdriver.ActionChains(driver).send_keys(Keys.ESCAPE).perform()
+```
+
+또한, 스크린샷 저장 기능도 필요합니다. 이 기능은 브라우저의 스크린샷을 찍어 `step_log.observations_images = [image.copy()]`에 저장합니다. 이를 통해 에이전트가 탐색 중 이미지를 동적으로 저장하고 활용할 수 있습니다.
+
+```python
+def save_screenshot(step_log: ActionStep, agent: CodeAgent) -> None:
+    sleep(1.0)  # 자바스크립트 애니메이션 대기
+    driver = helium.get_driver()
+    current_step = step_log.step_number
+    if driver is not None:
+        for step_logs in agent.logs:  # 이전 스크린샷 정리
+            if isinstance(step_log, ActionStep) and step_log.step_number <= current_step - 2:
+                step_logs.observations_images = None
+        png_bytes = driver.get_screenshot_as_png()
+        image = Image.open(BytesIO(png_bytes))
+        print(f"브라우저 스크린샷 캡처: {image.size} 픽셀")
+        step_log.observations_images = [image.copy()]
+
+    # 현재 URL 정보 업데이트
+    url_info = f"현재 url: {driver.current_url}"
+    step_log.observations = url_info if step_logs.observations is None else step_log.observations + "\n" + url_info
+    return
+```
+
+이 함수는 `step_callback`으로 에이전트에 전달되어, 각 단계가 끝날 때마다 실행됩니다. 이를 통해 에이전트는 탐색 과정에서 스크린샷을 동적으로 저장할 수 있습니다.
+
+이제, 브라우저를 탐색하며 시각 정보를 활용하는 비전 에이전트를 만들어봅시다. 앞서 만든 도구들과 `DuckDuckGoSearchTool`을 함께 사용합니다. 이 도구는 손님 신원 확인에 필요한 정보를 웹에서 검색하는 데 도움을 줍니다.
+
+```python
+from smolagents import CodeAgent, OpenAIServerModel, DuckDuckGoSearchTool
+model = OpenAIServerModel(model_id="gpt-4o")
+
+agent = CodeAgent(
+    tools=[DuckDuckGoSearchTool(), go_back, close_popups, search_item_ctrl_f],
+    model=model,
+    additional_authorized_imports=["helium"],
+    step_callbacks=[save_screenshot],
+    max_steps=20,
+    verbosity_level=2,
+)
+```
+
+이제 Alfred는 손님 신원 확인을 위해 다음과 같이 에이전트를 실행할 수 있습니다:
+
+```python
+agent.run("""
+나는 Wayne Manor의 집사 Alfred로, 파티에 참석하는 손님의 신원을 확인하는 임무를 맡고 있습니다. 한 슈퍼히어로가 Wonder Woman이라고 주장하며 입장하려고 하는데, 정말 그녀가 맞는지 확인해야 합니다.
+
+Wonder Woman의 이미지를 검색해 시각적 특징을 자세히 설명해 주세요. 또한, Wikipedia에서 그녀의 외모에 대한 주요 정보를 찾아주세요. 이 정보를 바탕으로 입장 허가 여부를 결정하겠습니다.
+""" + helium_instructions)
+```
+
+여기서 `helium_instructions`는 탐색을 제어하는 특수 프롬프트로, 에이전트가 올바른 순서로 웹을 탐색하도록 유도합니다.
+
+아래 영상에서 실제 동작을 확인할 수 있습니다:
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/rObJel7-OLc?si=TnNwQ8rqXqun_pqE" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+최종 출력 예시는 다음과 같습니다:
+
+```python
+Final answer: Wonder Woman은 일반적으로 빨간색과 금색의 상의, 파란색 별무늬 하의, 금색 티아라, 은색 팔찌, 황금 올가미를 착용한 모습으로 묘사됩니다. 그녀는 Themyscira의 공주이자, 인간 세계에서는 Diana Prince로 알려져 있습니다.
+```
+
+이렇게 해서, 파티 입장 손님 신원 확인을 위한 비전 에이전트를 완성했습니다! 이제 Alfred는 올바른 손님만 입장할 수 있도록 완벽하게 준비할 수 있습니다. Wayne Manor에서 멋진 파티를 즐기세요!
+
+
+## 추가 자료
+
+- [We just gave sight to smolagents](https://huggingface.co/blog/smolagents-can-see) - 비전 에이전트 기능을 소개하는 블로그
+- [Web Browser Automation with Agents 🤖🌐](https://huggingface.co/docs/smolagents/examples/web_browser) - 웹 브라우저를 활용한 에이전트 예시
+- [Web Browser Vision Agent Example](https://github.com/huggingface/smolagents/blob/main/src/smolagents/vision_web_browser.py) - 웹 브라우저 비전 에이전트 예시
diff --git a/units/ko/unit2/smolagents/why_use_smolagents.mdx b/units/ko/unit2/smolagents/why_use_smolagents.mdx
new file mode 100644
index 00000000..4bda418b
--- /dev/null
+++ b/units/ko/unit2/smolagents/why_use_smolagents.mdx
@@ -0,0 +1,67 @@
+![smolagents banner](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/smolagents/license_to_call.png)
+# smolagents를 써야 하는 이유
+
+이 모듈에서는 [smolagents](https://huggingface.co/docs/smolagents/en/index)를 사용할 때의 장단점을 살펴보고, 여러분의 필요에 맞는 프레임워크인지 판단할 수 있도록 도와드립니다.
+
+## `smolagents`란?
+
+`smolagents`는 간단하면서도 강력한 AI 에이전트 프레임워크입니다. LLM이 검색, 이미지 생성 등 실제 세계와 상호작용할 수 있는 _에이전시(agency)_ 를 제공합니다.
+
+unit 1에서 배운 것처럼, AI 에이전트는 LLM이 **'관찰(observations)'**을 바탕으로 **'생각(thoughts)'**을 생성해 **'행동(actions)'**을 수행하는 프로그램입니다. smolagents에서 이것이 어떻게 구현되는지 살펴봅시다.
+
+### `smolagents`의 주요 장점
+- **단순함:** 최소한의 코드 복잡성과 추상화로 프레임워크를 쉽게 이해하고, 도입 및 확장할 수 있습니다.
+- **유연한 LLM 지원:** Hugging Face 도구 및 외부 API와의 통합을 통해 어떤 LLM과도 연동할 수 있습니다.
+- **코드 우선 접근:** 액션을 직접 코드로 작성하는 Code Agent를 1급 시민으로 지원하여, 파싱 없이 도구 호출을 단순화합니다.
+- **HF Hub 통합:** Hugging Face Hub와의 원활한 통합으로 Gradio Spaces를 도구로 활용할 수 있습니다.
+
+### smolagents를 언제 사용해야 할까?
+
+이러한 장점을 고려할 때, 다른 프레임워크 대신 smolagents를 사용해야 하는 경우는 언제일까요?
+
+smolagents는 다음과 같은 상황에 이상적입니다:
+- **가볍고 최소한의 솔루션**이 필요할 때
+- **복잡한 설정 없이 빠르게 실험**하고 싶을 때
+- **애플리케이션 로직이 단순**할 때
+
+### 코드 vs. JSON 액션
+다른 프레임워크에서는 에이전트가 액션을 JSON으로 작성하는 반면, `smolagents`는 **코드 기반 도구 호출**에 집중하여 실행 과정을 단순화합니다. 도구 호출을 위한 코드를 직접 생성하므로, JSON을 파싱해 코드를 만드는 과정이 필요 없습니다. 즉, 출력된 코드를 바로 실행할 수 있습니다.
+
+아래 다이어그램은 이 차이를 보여줍니다:
+
+![Code vs. JSON actions](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/code_vs_json_actions.png)
+
+Code vs JSON 액션의 차이를 다시 보고 싶다면 [Unit 1의 액션 섹션](https://huggingface.co/learn/agents-course/unit1/actions#actions-enabling-the-agent-to-engage-with-its-environment)을 참고하세요.
+
+### smolagents의 에이전트 유형
+
+smolagents의 에이전트는 **다단계 에이전트(multi-step agent)**로 동작합니다.
+
+각 [`MultiStepAgent`](https://huggingface.co/docs/smolagents/main/en/reference/agents#smolagents.MultiStepAgent)는 다음을 수행합니다:
+- 한 번의 생각(thought)
+- 한 번의 도구 호출 및 실행
+
+주요 에이전트 타입으로 **[CodeAgent](https://huggingface.co/docs/smolagents/main/en/reference/agents#smolagents.CodeAgent)**를 사용하며, 도구 호출을 JSON으로 작성하는 **[ToolCallingAgent](https://huggingface.co/docs/smolagents/main/en/reference/agents#smolagents.ToolCallingAgent)**도 지원합니다.
+
+각 에이전트 타입은 이후 섹션에서 자세히 다룹니다.
+
+<Tip> 
+smolagents에서는 도구를 <code>@tool</code> 데코레이터로 감싼 Python 함수 또는 <code>Tool</code> 클래스로 정의합니다.
+</Tip>
+
+### smolagents의 모델 통합
+`smolagents`는 유연한 LLM 통합을 지원하여, [특정 기준](https://huggingface.co/docs/smolagents/main/en/reference/models)을 충족하는 어떤 호출 가능한 모델도 사용할 수 있습니다. 프레임워크는 모델 연결을 단순화하는 여러 사전 정의 클래스를 제공합니다:
+
+- **[TransformersModel](https://huggingface.co/docs/smolagents/main/en/reference/models#smolagents.TransformersModel):** 로컬 `transformers` 파이프라인을 구현해 손쉬운 통합을 지원합니다.
+- **[InferenceClientModel](https://huggingface.co/docs/smolagents/main/en/reference/models#smolagents.InferenceClientModel):** [Hugging Face 인프라](https://huggingface.co/docs/api-inference/index) 또는 다양한 [서드파티 추론 제공업체](https://huggingface.co/docs/huggingface_hub/main/en/guides/inference#supported-providers-and-tasks)를 통한 [서버리스 추론](https://huggingface.co/docs/huggingface_hub/main/en/guides/inference) 호출을 지원합니다.
+- **[LiteLLMModel](https://huggingface.co/docs/smolagents/main/en/reference/models#smolagents.LiteLLMModel):** [LiteLLM](https://www.litellm.ai/)을 활용한 경량 모델 연동을 지원합니다.
+- **[OpenAIServerModel](https://huggingface.co/docs/smolagents/main/en/reference/models#smolagents.OpenAIServerModel):** OpenAI API 인터페이스를 제공하는 모든 서비스와 연결할 수 있습니다.
+- **[AzureOpenAIServerModel](https://huggingface.co/docs/smolagents/main/en/reference/models#smolagents.AzureOpenAIServerModel):** Azure OpenAI 배포와의 통합을 지원합니다.
+
+이러한 유연성 덕분에 개발자는 각자의 용도에 가장 적합한 모델과 서비스를 선택할 수 있으며, 실험도 쉽게 할 수 있습니다.
+
+이제 smolagents를 왜, 언제 써야 하는지 이해했으니, 이 강력한 라이브러리를 더 깊이 탐구해봅시다!
+
+## 참고 자료
+
+- [smolagents 블로그](https://huggingface.co/blog/smolagents) - smolagents와 코드 상호작용 소개