Hamp의 분리수거함

바이너리 분석하기

Hamp — Sat, 16 May 2026 20:03:53 +0900

들어가기 전

랭그래프 포스팅 이후, 약 3개월만의 포스팅이다..

회사와 사이드에 치이다보니, 학습시간이 많이 없어 포스팅을 할께 없었다.

이번 포스팅은 최근 회사에서 바이너리를 분석하는 경험을 하게되었는데, 그 때 알게된 지식과 유용한 tool 사용버을 기록하고자한다.

학습할 내용

nm
otool

✊ nm

유닉스 계열 운영체제의 object, 실행, 라이브러리등
파일내에 포함된 심볼을 확인하는 도구

역할

컴파일/링크 오류 디버깅
라이브러리 분석
바이너리 분석

명령어

nm -[옵션 나열..] [파일]

옵션	설명
-n (numeric-sort)	주소 순서대로 정렬
-u (undefined-only)	정의도지 않은 심볼만
-C (Demangle)	Mangling 심볼을 다시 사람이 읽기 쉬운 형태로 변환
-D (dyamic)	동적 심볼로 표시 (공유 라이브러리 분석 시 유용)
-p (no-sort)	정렬하지 않고 파일 순서대로 출력
--define-only	정의된 심볼만 출력 (정적 라이브러리 내 제공 심볼 확인)
-S	크기 및 끝 주소 필드 추가
--size-sort	크기 내람차순 정렬

분석

먼저 출력 결과는 다음과 같이 구성되어있다.

[주소] [심볼 타입] [심볼 이름]

심볼 타입

대문자는 외부공개(전역), 소문자는 내부용

T/t	코드 섹션에 있는 심볼로, 보통 함수를 의미
D/d	Data영역, 초기화된 전역 변수나 정적 변수가 위치하는 섹션
B/b	BSS영역, 초기화되지 않은 전역 변수가 위치하는 섹션
S/s	data section, (small 포함, ObjC metadata 포함 가능)
U	해당 파일 내에 정의되어 있지 않고, 외부에서 가져와야 하는 심볼
R/r	읽기 전용
W/ V	약(weak) 심볼, 링커가 중복 시 강 심볼로 대체
C	공용(Common)심볼

간단한 예제와 실제결과물과 함께 분석을해보자.

objc코드냐, swift코드냐에 따라 조금 포맷이 갈린다.

Objc: OBJC로 시작
Swift: $s로 시작: mangled symbol

// OBJC
0000000002ec8e88 S _OBJC_CLASS_$_WXWebViewController

// Swift
000000000175b260 s _$s12FirebaseAuth19ActionCodeOperationOMB
000000000031d1dc T _$s12FirebaseAuth19ActionCodeOperationOMa
00000000017dfb20 s _$s12FirebaseAuth19ActionCodeOperationOMf
00000000016a3354 S _$s12FirebaseAuth19ActionCodeOperationOMn
00000000017dfb30 S _$s12FirebaseAuth19ActionCodeOperationON
00000000014cc838 S _$s12FirebaseAuth19ActionCodeOperationOSHAAMc
0000000001a1ff00 b _$s12FirebaseAuth19ActionCodeOperationOSHAAMcMK
000000000031d160 t _$s12FirebaseAuth19ActionCodeOperationOSHAASH13_rawHashValue4seedS2i_tFTW

여기서 swift와 Objc는

_ $s → Swift symbol
s, t, T -> 심볼 타입
12FirebaseAuth: 모듈명길이 + 모듈명
19ActionCodeOpetion: 타입명길이 + 타입명
Suffx: 런타임 메타데이터, 최종 어떤 구조인지 추측할 수 있는 정보

☝️otool

Mach-O 해부기

역할

Mach-O 내부 구조를 분석
@rpath
linking 분석
중복 framework 분석

명령어

ottol -[옵션] [Mach-O 바이너리]

옵션	설명
-L	의존하는 dynamic library 조회
-l	Load Commands
-h	Mach header 분석

소감 및 마무리

목적	nm	tool
함수 심볼 보기	O	△
undefined symbol 확인	O	O
dylib dependency	X	O
rpath 확인	X	O
Mach-O 구조	X	O
dynamic/static 판단	△	O
disassemble	△	O

출처

https://jinolab.tistory.com/254

nm 도구로 ELF/오브젝트 심볼 한눈에 파악하기

nm(GNU binutils 패키지)는 실행 파일(ELF), 오브젝트(.o), 라이브러리(.a) 안에포함된 심볼-‐함수·변수·섹션·링커 심볼-‐을 목록화해주소·크기·속성(정의/미정의, 글로벌/로컬 등)을 보여주는 전통

jinolab.tistory.com

히스토리 관리

Hamp — Thu, 26 Feb 2026 22:20:10 +0900

학습할 내용

히스토리 관리가 필요한 이유
- 히스토리 관리 시작하기
최적화를 위한 삭제
- Remove 담당 Node
Human-in-the-loop

히스토리

1️⃣ 히스토리 관리가 필요한 이유

중간에 장애가 발생해도 복구할 수 있음
대화 / 작업 흐름을 유지할 수 있음
Human-in-the-loop: 개발자가 개입하여, 검토 및 수정을 할 수 있음
디버깅 및 추적이 간편함

2️⃣ 히스토리 관리 시작하기

checkpoints를 활용, Snapshot을 만듬, 우리는 간단한 MemorySaver checkpointer를 이용함

checkpointer는 매 실행마다, 상태 스냅샷(checkpoint)를 thread에 누적하게 됨

Thread란?

checkpointer가 저장하는 checkpoint들을 묶는 고유 ID
그래프를 실행할 때, configuable.thread_id를 반드시 지정해야함

# 그래프 구성

from langgraph.graph import START, END


graph_builder.add_edge(START, 'agent')
graph_builder.add_conditional_edges(
    'agent',
    should_continue,
    ['tools', 'summarize_messages']
)
graph_builder.add_edge('tools', 'agent')
graph_builder.add_edge('summarize_messages', 'delete_messages')
graph_builder.add_edge('delete_messages', END)


# 체크 포인터 지정, compile함수의 매개변수로 넘겨줌

from langgraph.checkpoint.memory import MemorySaver

checkpointer = MemorySaver()

graph= graph_builder.compile(checkpointer=checkpointer)


# config주기 


from langchain_core.messages import HumanMessage

config = {
    'configurable': {
        'thread_id': 'summarize_paper' # thread_id
    }
}

query = 'jasonkang14@gmail.com으로 Attention Is All You Need 논문을 요약해서 이메일 초안을 작성해주세요'
for chunk in graph.stream({'messages': [HumanMessage(query)], 'summary': ''}, config=config, stream_mode='values'):
    chunk['messages'][-1].pretty_print()

️ 최적화를 위한 메시지 삭제

한번 다음과 같은 모습을 상상해보자.

현재 메시지 리스트가 다음과 같이 있을 때, llm에게 저 내용 전체를 넘겨주는게 좋을까, 아니면 불필요할까?

보통은 그렇게 좋은 편은아니다.

물론 llm은 메시지 내용 전체를 알고 있으면, 조금더 답변의 정확도나 내용이 좋아지는 건 맞지만

우리는 한정된 리소스안에서 문제를 최대한 해결해야한다.

그렇기 떄문에 여기서 우리는, 메시지 전부를 넘겨줄 필요는 없다.

이 때, 삭제하기전에 앞의 내용을 요약한 후, 마지막 메시지와 함께 넘겨주게되면

두마리 토끼를 잡을 수 있다.

한번 살펴보자.

1️⃣ RemoveMessage 이용하기

요약하기

def summarize_messages(state: AgentState) -> AgentState:
    """
    주어진 state의 메시지를 요약합니다.

    Args:
        state (AgentState): 메시지와 요약을 포함하는 state.

    Returns:
        AgentState: 요약된 메시지를 포함하는 딕셔너리.
    """
    # state에서 메시지와 요약을 가져옵니다.
    messages = state['messages']
    summary = state['summary']
    
    # 요약 프롬프트를 생성합니다.
    summary_prompt = f'summarize this chat history below: \n\nchat_history:{messages}'
    
    # 기존 요약이 있으면, 요약을 포함한 프롬프트를 생성합니다.
    if summary != '':
        summary_prompt = f'''summarize this chat history below while looking at the summary of earlier conversations
chat_history:{messages}
summary:{summary}'''
    
    # LLM을 사용하여 요약을 생성합니다.
    summary = small_llm.invoke(summary_prompt)
    
    # 요약된 메시지를 반환합니다.
    return {'summary': summary.content}

삭제하기

rom langchain_core.messages import RemoveMessage

def delete_messages(state: AgentState) -> AgentState:
    """
    주어진 state에서 오래된 메시지를 삭제합니다.

    Args:
        state (AgentState): 메시지를 포함하는 state.

    Returns:
        AgentState: 삭제된 메시지를 포함하는 새로운 state.
    """
    # state에서 메시지를 가져옵니다.
    messages = state['messages']
    # 마지막 세 개의 메시지를 제외한 나머지 메시지를 삭제합니다.
    delete_messages = [RemoveMessage(id=message.id) for message in messages[:-3]]
    # 삭제된 메시지를 포함하는 새로운 state를 반환합니다.
    return {'messages': delete_messages}

그래프

from typing import Literal

def should_continue(state: AgentState) -> Literal['tools', 'summarize_messages']:
    """
    주어진 state에 따라 다음 단계로 진행할지를 결정합니다.

    Args:
        state (AgentState): 메시지와 도구 호출 정보를 포함하는 state.

    Returns:
        Literal['tools', 'summarize_messages']: 다음 단계로 'tools' 또는 'summarize_messages'를 반환합니다.
    """
    # state에서 메시지를 가져옵니다.
    messages = state['messages']
    # 마지막 AI 메시지를 확인합니다.
    last_ai_message = messages[-1]
    
    # 마지막 AI 메시지가 도구 호출을 포함하고 있는지 확인합니다.
    if last_ai_message.tool_calls:
        # 도구 호출이 있으면 'tools'를 반환합니다.
        return 'tools'
    
    # 도구 호출이 없으면 'summarize_messages'를 반환합니다.
    return 'summarize_messages'

graph_builder.add_node('agent', agent)
graph_builder.add_node('tools', tool_node)
graph_builder.add_node(delete_messages)
graph_builder.add_node(summarize_messages)


from langgraph.graph import START, END


graph_builder.add_edge(START, 'agent')
graph_builder.add_conditional_edges(
    'agent',
    should_continue,
    ['tools', 'summarize_messages']
)
graph_builder.add_edge('tools', 'agent')
graph_builder.add_edge('summarize_messages', 'delete_messages')
graph_builder.add_edge('delete_messages', END)

agent를 tools를 사용하여 llm 답변을 생성하고
이후 요약

Human-in-the-loop

⭐ 정의

에이전트가 “도구(tool)”를 실행하려고 할 때,
사람이 중간에 끼어들어 승인/수정/거절을 할 수 있게 하는 미들웨어

역할

aprrove: 도구 호출을 그대로 실행
edit: 도구의 args등을 수정한 후, 실행
rejcet: 실행하지 않고 거절 사유/피드백을 대화에 추가

HITL(Human-in-the-loop)를 할 떄 체크포인터가 없을 경우, 에러가 발생함

구성 요소

interrupt(input_payload)
- 중단
- input_payload: 유저에게 전달될 내용 (딕셔너리 형태)
- 유저는 이걸보고, 다음 스탭을 어떻게할 지 정함
Command(resume=human_input)
- human_input: interrupt 함수의 리턴값 (딕셔너리 형태)
- a = interrupt() , a에 human_input 값이 들아감
Command(goto='다음 목적지 노드이름', update={업데이트 내용})
- goto: 다음 목적지 이름
- update: 업데이트될 내용 (딕셔너리 형태)

다음 3가지 경우를 한번 살펴보자.

LLM이 재대로 된 답변을 했을 경우 -> 그대로 진행
도구를 잘 선택했지만, args를 수정할 경우 -> args만 수정 후 실행
도구를 잘못 선택했을 경우 -> 도구를 수정해줌

from typing import Literal
from langgraph.types import interrupt, Command

def human_review(state: AgentState) -> Command[Literal['tools', 'agent']]:
    """
    human_review node는 LLM의 도구 호출에 대해 사람의 검토를 요청합니다.

    Args:
        state (AgentState): 메시지 기록을 포함하는 state.

    Returns:
        Command: 다음 node로 이동하기 위한 Command를 반환합니다.
    """
    messages = state['messages']
    last_message = messages[-1]
    tool_call = last_message.tool_calls[-1]
    human_review = interrupt({
        'question': '이렇게 진행하면 될까요?',
        'tool_call': tool_call
    })
    review_action = human_review['action']
    review_data = human_review.get('data', None)
    
    if review_action == 'continue':
        # 에이전트의 판단이 맞다면, 도구를 사용하기 위해 아무것도 수정하지 않고 `tools` 노드로 이동합니다
        return Command(goto='tools')
    
    if review_action == 'update_args':
        # 도구를 더 효율적으로 사용하기 위해 AIMessage의 `tool_calls` 필드를 업데이트합니다
        updated_ai_message = {
            'id': last_message.id,
            'role': 'ai',
            'content': last_message.content,
            'tool_calls': [{
                'id': tool_call['id'],
                'name': tool_call['name'],
                'args': review_data
            }],
        }
        return Command(goto='tools', update={'messages': [updated_ai_message]})
    
    if review_action == 'update_tool':
        # 다른 도구를 사용하기 위해 `ToolMessage`를 업데이트합니다 
        updated_tool_message = {
            'tool_call_id': tool_call['id'],
            'name': tool_call['name'],
            'role': 'tool',
            'content': review_data
        }
        return Command(goto='agent', update={'messages': [updated_tool_message]})

이후 커맨드,

for chunk in graph.stream(
    Command(resume={"action": "continue"}),
    config,
    stream_mode="updates", # 값을 업데이트 할 때, 여기가 꼭 updates로
):
    print(f'chunk == {chunk}')

출처

https://wikidocs.net/261582

1-4. 메모리 (Memory)

LangGraph의 **메모리(Memory)** 기능은 그래프의 상태를 저장하고 복원하는 핵심 메커니즘입니다. 이를 통해 대화의 맥락을 유지하고, 오류 발생 시 안전하게 복구하며…

wikidocs.net

https://docs.langchain.com/oss/python/langgraph/persistence

Persistence - Docs by LangChain

LangGraph has a built-in persistence layer, implemented through checkpointers. When you compile a graph with a checkpointer, the checkpointer saves a checkpoint of the graph state at every super-step. Those checkpoints are saved to a thread, which can be a

docs.langchain.com

https://github.com/jasonkang14/inflearn-langgraph-agent/blob/main/3.5%20Agent%EC%9D%98%20%ED%9E%88%EC%8A%A4%ED%86%A0%EB%A6%AC%EB%A5%BC%20%EA%B4%80%EB%A6%AC%ED%95%98%EB%8A%94%20%EB%B0%A9%EB%B2%95.ipynb

inflearn-langgraph-agent/3.5 Agent의 히스토리를 관리하는 방법.ipynb at main · jasonkang14/inflearn-langgraph-agent

인프런의 "LangGraph를 활용한 AI Agent 개발" 강의 소스코드입니다. Contribute to jasonkang14/inflearn-langgraph-agent development by creating an account on GitHub.

github.com

https://github.com/jasonkang14/inflearn-langgraph-agent/blob/main/3.6%20human-in-the-loop%20%EC%82%AC%EB%9E%8C%EC%9D%B4%20Agent%EC%99%80%20%EC%86%8C%ED%86%B5%ED%95%98%EB%8A%94%20%EB%B0%A9%EB%B2%95.ipynb

inflearn-langgraph-agent/3.6 human-in-the-loop 사람이 Agent와 소통하는 방법.ipynb at main · jasonkang14/inflearn-lang

인프런의 "LangGraph를 활용한 AI Agent 개발" 강의 소스코드입니다. Contribute to jasonkang14/inflearn-langgraph-agent development by creating an account on GitHub.

github.com

tool

Hamp — Tue, 24 Feb 2026 22:12:17 +0900

학습할 내용

랭체인 tool 활용
랭그래프에서 tool 제공

⛓️ LangChain tool 제공

1️⃣ tool 만들기

랭체인에서 tool은 schema를 가진 함수다.

@tool 데코레이
설명
파라미터 및 리턴 타입

from langchain_core.tools import tool

@tool
def add(a: int, b: int) -> int:
    """숫자 a와 b를 더합니다."""
    return a + b

@tool
def multiply(a: int, b: int) -> int:
    """숫자 a와 b를 곱합니다."""
    return a * b

2️⃣ llm에 바인딩

small_llm = AzureChatOpenAI(
    azure_deployment='gpt-4o-mini-2024-07-18',
    api_version='2024-08-01-preview',
)

llm_with_tools = small_llm.bind_tools([add, multiply])

3️⃣ 메시지 리스트(시퀀스) 던져주기

왜 리스트를 던져 줘야하나 ?
llm에게 단순 질문을 던져주는 것보다 다음과 같이 던져주는게좋음
- 질문 -> 휴면 메시지
- AI메시지
  - 도구가 필요한지 안한지, 결정 후, 도구가 필요하면 AI메시지 안에있는 tool_calls에 bind한 도구 중 필요한게 전달됨
- Tool메시지
  - 해당 Tool을 쓴 결과

from typing import Sequence

from langchain_core.messages import AnyMessage, HumanMessage

human_message = HumanMessage(query) # 3 곱하기 5는
message_list: Sequence[AnyMessage] = [human_message]

ai_message = llm_with_tools.invoke(message_list) # AI 메시지 
message_list.append(ai_message)

tool_message = multiply.invoke(ai_message.tool_calls[0]) #Tool 메시지
message_list.append(tool_message)


llm_with_tools.invoke(message_list) # Tool이 있는 LLM 호출

⚓ LangGraph에서 tool 제공

위 내용에서 크게 바뀌는 부부만 살펴보자.

message_list -> MessagesState
- append를 일일히 하지 않아도 됨
- MessagesState는 add_messages로 자동으로 추가됨

class MessagesState(TypedDict):
    messages: Annotated[list[AnyMessage], add_messages]

ToolNode 이용
- tool을 그래프의 노드로 치환 시킴
- Tool 노드는 아래 제약조건을 반드시 지켜야한다.
  - 메시지의 배열을 포함해야한다.
    - AnyMessage
      - SystemMessage
      - AIMessage
      - HumanMessage
      - ToolMessage
  - 마지막 메시지는 반드시 AIMessage여야한다.
  - AIMessage는 반드시 tool_calls(선택된 tool) 있어야한다.

from langgraph.prebuilt import ToolNode

tool_list = [add, multiply]
llm_with_tools = small_llm.bind_tools(tool_list) # LLM에 tool 바인딩
tool_node = ToolNode(tool_list) # ToolNode 생성

from langgraph.prebuilt import ToolNode

tool_list = [add, multiply]
llm_with_tools = small_llm.bind_tools(tool_list)
tool_node = ToolNode(tool_list)

from langgraph.graph import MessagesState, StateGraph

graph_builder = StateGraph(MessagesState)

# %%
def agent(state: MessagesState) -> MessagesState:
    """
    에이전트 함수는 주어진 상태에서 메시지를 가져와
    LLM과 도구를 사용하여 응답 메시지를 생성합니다.

    Args:
        state (MessagesState): 메시지 상태를 포함하는 state.

    Returns:
        MessagesState: 응답 메시지를 포함하는 새로운 state.
    """
    # 상태에서 메시지를 추출합니다.
    messages = state['messages']
    
    # LLM과 도구를 사용하여 메시지를 처리하고 응답을 생성합니다.
    response = llm_with_tools.invoke(messages)
    
    # 응답 메시지를 새로운 상태로 반환합니다.
    return {'messages': [response]}

# %%
from typing import Literal
from langgraph.graph import END

def should_continue(state: MessagesState) -> Literal['tools', END]:
    """
    주어진 메시지 상태를 기반으로 에이전트가 계속 진행할지 여부를 결정합니다.

    Args:
        state (MessagesState): `state`를 포함하는 객체.

    Returns:
        Literal['tools', END]: 도구를 사용해야 하면 `tools`를 리턴하고, 
        답변할 준비가 되었다면 END를 반환해서 프로세스를 종료합니다.
    """
    # 상태에서 메시지를 추출합니다.
    messages = state['messages']
    
    # 마지막 AI 메시지를 가져옵니다.
    last_ai_message = messages[-1]
    
    # 마지막 AI 메시지가 도구 호출을 포함하고 있는지 확인합니다.
    if last_ai_message.tool_calls:
        # 도구 호출이 있으면 'tools'를 반환합니다.
        return 'tools'
    
    # 도구 호출이 없으면 END를 반환하여 프로세스를 종료합니다.
    return END

출처

지금까지 우리가 만든건 Agent가 아니다??

Hamp — Mon, 23 Feb 2026 22:23:44 +0900

들어가기 전

우리가 지금까지 만들었던, 그래프들을 에이전트로가 불러왔었는데, 사실 Agent가 아니였다라는

충격적인 반전과 함께, 진짜 Agent는 어떤 것인지 알아보자.

학습할 내용

우리가 만들어왔던 Agent 복습
그렇다면 우리가 만든건 뭘까?
진짜 Agent란 ??

이전 그래프

1️⃣ Agentic RAG

LLM이 Retrieval 여부 결정
문서와 관련도 판별 후, rewrite 여부 또는 END

2️⃣ Self RAG

문서 관련도 측정 (RetrievalGrader)
환각 점검 (Hallucination Grader)
질문과 답변 관련성 점검 (Answer Grader)

3️⃣Rotuer

입려된 정보를 분류하여, 최적으 Node에게 보냄

4️⃣병렬

아래 로직을 돌리기 위해 필요한 독립적은 노드들을 병렬로 진행

️ Agentic system

workflow + agents = agentic systems

❓ 우리가 만든건 뭘까??

자 여기서부터는 출처에 있는 엔토리픽 문서에 나와있는 내용이다.

위 사진은 엔트로픽 공식문서에 있는 내용인데, 우리가 그렸던 그래프들이랑 너무 똑같다..

그러면 이 내용은 엔트로픽에서 뭐라고 부를까 ??

바로 workflow다.

엔트로픽은 workflow를 다음과 같이 정의하고 있다.

LLM과 사전 정의된 코드 경로를 통해 LLM과 도구들이 유기적으로 조율된 시스템이다.

여기서 핵심은 사전 정의된, 즉 순서와 분기등을 "개발자"가 정의했다는 것

❕진짜 Agent란

LLM이 동적으로 스스로 프로세스와 도구 사용을 결정
작업을 해결하는 방법과 순서를 모델이 직접 결정하고 통제

출처

https://www.anthropic.com/engineering/building-effective-agents

Building Effective AI Agents

Discover how Anthropic approaches the development of reliable AI agents. Learn about our research on agent capabilities, safety considerations, and technical framework for building trustworthy AI.

www.anthropic.com

RunnablePassthrough

Hamp — Mon, 23 Feb 2026 21:14:08 +0900

⭐ 역할

역할

데이터를 변환하거나 수정할 필요가 없는 경우
파이프라인의 특정 단계를 건너뛰어야 하는 경우
디버깅 또는 테스트 목적으로 데이터 흐름을 모니터링해야 하는 경우

예제로 흐름 파악하기

tax_deduction_question가 invoke를 통해, tax_deduction_chain의 question: RunnablePassthrough로 들어감
마찬가지로 tax_base_equation_question이 tax_base_retrieval_chain의 question: RunnablePassthrough로 들어감
tax_base_equation_chain의 tax_base_equation_information에는 tax_base_retrieval_chain이 들어옴

tax_base_retrieval_chain = (
    {'context': retriever, 'question': RunnablePassthrough()} 
    | rag_prompt 
    | llm 
    | StrOutputParser()
)

tax_base_equation_prompt = ChatPromptTemplate.from_messages([
    ('system', '사용자의 질문에서 과세표준을 계산하는 방법을 수식으로 나타내주세요. 부연설명 없이 수식만 리턴해주세요'),
    ('human', '{tax_base_equation_information}')
])

tax_base_equation_chain = (
    {'tax_base_equation_information': RunnablePassthrough()}
    | tax_base_equation_prompt
    | llm
    | StrOutputParser()
)

tax_base_chain = {'tax_base_equation_information' : tax_base_retrieval_chain} | tax_base_equation_chain

def get_tax_base_equation(state: AgentState) -> AgentState:
    tax_base_equation_question = '주택에 대한 종합부동산세 계산시 과세표준을 계산하는 방법을 수식으로 표현해서 알려주세요'
    tax_base_equation = tax_base_chain.invoke(tax_base_equation_question)

    return {'tax_base_equation': tax_base_equation}
    
    tax_deduction_chain = (
    {'context': retriever, 'question': RunnablePassthrough()} 
    | rag_prompt 
    | llm 
    | StrOutputParser()
)

def get_tax_deduction(state: AgentState) -> AgentState:
    # 공제금액을 묻는 질문을 정의합니다.
    tax_deduction_question = '주택에 대한 종합부동산세 계산시 공제금액을 알려주세요'
    
    # tax_deduction_chain을 사용하여 질문을 실행하고 결과를 얻습니다.
    tax_deduction = tax_deduction_chain.invoke(tax_deduction_question)
    
    # state에서 'tax_deduction' 키에 대한 값을 반환합니다.
    return {'tax_deduction': tax_deduction}

출처

https://wikidocs.net/235580

01. RunnablePassthrough

.custom { background-color: #008d8d; color: white; padding: 0.25em 0.5…

wikidocs.net

SubGraph와 Router

Hamp — Sun, 22 Feb 2026 22:45:02 +0900

들어가기 전

이번 내용은 이전에 만들었던, Self Rag, Corrective Rag, 신규 Graph를 모두 묶을려고한다.

새로 등장하는 SubGraph와 Router를 이용해서 한번 진행해보자.

Router

⭐정의

그래프의 흐름을 결정하는 핵심적인 의사결정 장치

역할

입력된 정보를 분류하고, 이를 해당 분야의 전담 에이전트(Specialized Agents)에게 보내는 역할

➡️ Sub Graph

⭐정의

다른 그래프 안에서 하나의 노드(Node)처럼 사용되는 독립된 그래프

역할

멀티 에이전트 시스템 구축
- 각 에이전트가 수행하는 복잡한 단계를 별도의 그래프로 분리하여 관리 가능
코드 재사용
- 공통적으로 쓰이는 작업 흐름(예: 데이터 정제, 검색 로직)을 서브그래프로 만들어 여러 상위 그래프에서 재사용 가능
개발 분업화
- 자기 담당 영역(서브그래프)의 입력과 출력만 맞추면, 내부 로직이 어떻게 돌아가는지 상위 그래프 팀이 몰라도 독립적으로 개발 가

예제

우리의 목표는 다음과 같다.

이전 vector_store에 있는 정보가 있을 때는 Self-RAG 그래프를 이용

간단한 작업일 경우, basic_generate 이용

웹 서치가 필요할 때는 Corrective RAG를 이용

목표 그래프

route를 통해, 어떤 Agent(Graph)를 이용할지 결정

정확히 어떤 경로가 존재하는 지 명확히 명시
- BaseModel
- with_structured_output
- 위 2개를 통해

from langchain_core.prompts import ChatPromptTemplate
from pydantic import BaseModel, Field
from typing import Literal

class Route(BaseModel):
    target: Literal['vector_store', 'llm', 'web_search'] = Field(
        description="The target for the query to answer"
    )

# 라우팅 관련 프롬포트
router_system_prompt = """
You are an expert at routing a user's question to 'vector_store', 'llm', or 'web_search'.
'vector_store' contains information about income tax up to December 2024.
if you think the question is simple enough use 'llm'
if you think you need to search the web to answer the question use 'web_search'
"""


router_prompt = ChatPromptTemplate.from_messages([
    ('system', router_system_prompt),
    ('user', '{query}')
])

router_llm = ChatOpenAI(model="gpt-4o-mini")
structured_router_llm = router_llm.with_structured_output(Route) # Router 클래스 형태로 반환

def router(state: AgentState) -> Literal['vector_store', 'llm', 'web_search']:
    """
    사용자의 질문에 기반하여 적절한 경로를 결정합니다.

    Args:
        state (AgentState): 사용자의 질문을 포함한 에이전트의 현재 state.

    Returns:
        Literal['vector_store', 'llm', 'web_search']: 질문을 처리하기 위한 적절한 경로를 나타내는 문자열.
    """
    # state에서 질문을 추출합니다
    query = state['query']
    
    # 프롬프트와 구조화된 라우터 LLM을 연결하여 체인을 생성합니다
    router_chain = router_prompt | structured_router_llm 
    
    # 체인을 사용하여 경로를 결정합니다
    route = router_chain.invoke({'query': query})

    # 결정된 경로의 타겟을 반환합니다
    return route.target

그래프 연결와 edge 연결

from income_tax_graph import graph as income_tax_subgraph

graph_builder.add_node('income_tax_agent', income_tax_subgraph)
graph_builder.add_node('web_search', web_search)
graph_builder.add_node('web_generate', web_generate)
graph_builder.add_node('basic_generate', basic_generate)

from langgraph.graph import START, END

graph_builder.add_conditional_edges(
    START, 
    router,
    {
        'vector_store': 'income_tax_agent',
        'llm': 'basic_generate',
        'web_search': 'web_search'
    }
)

graph_builder.add_edge('web_search', 'web_generate')
graph_builder.add_edge('web_generate', END)
graph_builder.add_edge('basic_generate', END)
graph_builder.add_edge('income_tax_agent', END)

출처

https://arxiv.org/abs/2403.14403

Adaptive-RAG: Learning to Adapt Retrieval-Augmented Large Language Models through Question Complexity

Retrieval-Augmented Large Language Models (LLMs), which incorporate the non-parametric knowledge from external knowledge bases into LLMs, have emerged as a promising approach to enhancing response accuracy in several tasks, such as Question-Answering (QA).

arxiv.org

https://docs.langchain.com/oss/python/langchain/multi-agent/router

Router - Docs by LangChain

Tutorial: Build a multi-source knowledge base with routing Build a router that queries GitHub, Notion, and Slack in parallel, then synthesizes results into a coherent answer. Covers state definition, specialized agents, parallel execution with Send, and re

docs.langchain.com

https://docs.langchain.com/oss/python/langgraph/use-subgraphs

Subgraphs - Docs by LangChain

Full example: different state schemas (two levels of subgraphs)

docs.langchain.com

https://github.com/jasonkang14/inflearn-langgraph-agent

GitHub - jasonkang14/inflearn-langgraph-agent: 인프런의 "LangGraph를 활용한 AI Agent 개발" 강의 소스코드입니

인프런의 "LangGraph를 활용한 AI Agent 개발" 강의 소스코드입니다. Contribute to jasonkang14/inflearn-langgraph-agent development by creating an account on GitHub.

github.com

Corrective RAG

Hamp — Sun, 22 Feb 2026 18:09:26 +0900

⭐ 정의

RAG + 웹서치

❓Self RAG와 다른점

re-write 목적이 다름
- Self RAG는 retrieve를 잘하려고 rewrite
- retrieve는 기존의 가지고 있는 VectorStore 기반
- Corrective RAG는 Web Search를 잘하기위해 rewrite

흐름

관련성 평가
- 통과 시, generate
- 실패 시, rewrite
rewrite
- Web Seach를 위해, rewrite
Web Search
- 검색 결과를 기반으로 generate

웹서치 전에 rewrite가 꼭 필요할까??

rewrite 역시 llm 호출이 필요하기 때문에, 굳이 필수는 아니다.
공식문서는 rewrite노드가 있지만, 결과물에 크게 영향을 주지 않는다.

출처

https://wikidocs.net/270686

03. CRAG(Corrective RAG)

.custom { background-color: #008d8d; color: white; padding: 0.25em 0.5…

wikidocs.net

https://arxiv.org/abs/2401.15884

Corrective Retrieval Augmented Generation

Large language models (LLMs) inevitably exhibit hallucinations since the accuracy of generated texts cannot be secured solely by the parametric knowledge they encapsulate. Although retrieval-augmented generation (RAG) is a practicable complement to LLMs, i

arxiv.org

Self RAG

Hamp — Sun, 22 Feb 2026 17:30:19 +0900

⭐ 정의

Self-RAG는 검색된 문서와 생성된 응답 모두에 대해 점검하고
검증하는 추가 단계를 포함하는 RAG 전략

흐름

단계	질문 (Self-Reflection)	노드
1. 관련성 점검	"내가 가져온 이 문서가 질문에 도움이 될까?"	Retrieval Grader
2. 환각 점검	"내가 쓴 답변이 문서에 있는 내용 기반인가?"	Hallucination Grader
3. 유용성 점검	"이 답변이 사용자의 질문에 직접적인 도움이 되나?"	Answer Grader

역할

신뢰도 극대화: 잘못된 정보가 사용자에게 전달될 확률을 획기적으로 낮춤
적응력: 문서가 부족하면 다시 검색하거나 질문을 다듬는 등 유연한 대처
정교한 제어: LangGraph를 쓰면 각 단계(노드)마다 다른 AI 모델 사용가능 (예: 판단은 가벼운 모델, 생성은 무거운 모델)

출처

https://wikidocs.net/270687

04. Self-RAG

.custom { background-color: #008d8d; color: white; padding: 0.25em 0.5…

wikidocs.net

https://arxiv.org/abs/2310.11511

Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection

Despite their remarkable capabilities, large language models (LLMs) often produce responses containing factual inaccuracies due to their sole reliance on the parametric knowledge they encapsulate. Retrieval-Augmented Generation (RAG), an ad hoc approach th

arxiv.org

Conditional Edge

Hamp — Sun, 22 Feb 2026 16:25:18 +0900

❓Conditional Edge 만들기

1️⃣ 기존 간단한 그래프

graph_builder.add_node('retrieve', retrieve)
graph_builder.add_node('generate', generate)

from langgraph.graph import START, END

graph_builder.add_edge(START, 'retrieve')
graph_builder.add_edge('retrieve', 'generate')
graph_builder.add_edge('generate', END)
graph = graph_builder.compile()

2️⃣ Conditional Edge가 있는 그래프

여기서 중요한 점은, 기존 노드와 차이점을 알아야한다.

기존 노드의 리턴은 State다.
기존 노드는 .add_node를 통해 등록된다.
Conditional Edge에 사용되는 노드에 일반적으로 등록되지 않는다.
Conditional Edge에 사용되는 노드는 State가 아닌 노드이름을 리턴한다.

from langchain import hub
from typing import Literal

def check_doc_relevance(state: AgentState) -> Literal['generate', 'rewrite']:
    """
    주어진 state를 기반으로 문서의 관련성을 판단합니다.

    Args:
        state (AgentState): 사용자의 질문과 문맥을 포함한 에이전트의 현재 state.

    Returns:
        Literal['generate', 'rewrite']: 문서가 관련성이 높으면 'generate', 그렇지 않으면 'rewrite'를 반환합니다.
    """
    query = state['query']  # state에서 사용자의 질문을 추출합니다.
    context = state['context']  # state에서 문맥을 추출합니다.

    # 문서 관련성 판단 체인을 구성합니다.
    doc_relevance_chain = doc_relevance_prompt | llm
    
    # 질문과 문맥을 사용하여 문서의 관련성을 판단합니다.
    response = doc_relevance_chain.invoke({'question': query, 'documents': context})

    # 관련성이 높으면 'generate'를 반환하고, 그렇지 않으면 'rewrite'를 반환합니다.
    if response['Score'] == 1:
        return 'generate'
    
    return 'rewrite'

graph_builder.add_node('retrieve', retrieve)
graph_builder.add_node('generate', generate)
graph_builder.add_node('rewrite', rewrite)

# check_doc_relevance 노드 등록 ❌


from langgraph.graph import START, END

graph_builder.add_edge(START, 'retrieve')
graph_builder.add_conditional_edges('retrieve', check_doc_relevance) # conditional_edge 등록
graph_builder.add_edge('rewrite', 'retrieve')
graph_builder.add_edge('generate', END)

3️⃣ Conditional Edge 추가 고급편

이렇게 처리하면, 그래프의 가독성이 훨씬 좋아진다.

graph_builder.add_conditional_edges(
    'retrieve',             # 시작점: 문서를 찾아온 후
    check_doc_relevance,    # 판단 함수: 이 문서가 질문과 관련 있는지 검사
    {
        'relevant': 'generate', # 관련 있다면 -> 답변 생성 단계로!
        'irrelevant': END       # 관련 없다면 -> 여기서 종료(END)
    }
)

Conidtional Edge 사용 시, 노드를 추가하고 싶다면, 다음과 같이 노드와
실제 동작할 노드(등록 안할 노드)를 구분한다.

여기서 check_heplfulness는 등록될 노드
check_heplfulness_grader는 실제 동작되고, 등록도지 않을 노드
check_heplfulness -> check_heplfulness_grader로 감

def check_helpfulness_grader(state: AgentState) -> str:
    """
    사용자의 질문에 기반하여 생성된 답변의 유용성을 평가합니다.

    Args:
        state (AgentState): 사용자의 질문과 생성된 답변을 포함한 에이전트의 현재 state.

    Returns:
        str: 답변이 유용하다고 판단되면 'helpful', 그렇지 않으면 'unhelpful'을 반환합니다.
    """
    # state에서 질문과 답변을 추출합니다
    query = state['query']
    answer = state['answer']

    # 답변의 유용성을 평가하기 위한 체인을 생성합니다
    helpfulness_chain = helpfulness_prompt | llm
    
    # 질문과 답변으로 체인을 호출합니다
    response = helpfulness_chain.invoke({'question': query, 'student_answer': answer})

    # 점수가 1이면 'helpful'을 반환하고, 그렇지 않으면 'unhelpful'을 반환합니다
    if response['Score'] == 1:
        return 'helpful'
    
    return 'unhelpful'

def check_helpfulness(state: AgentState) -> AgentState:
    """
    유용성을 확인하는 자리 표시자 함수입니다. 
    graph에서 conditional_edge를 연속으로 사용하지 않고 node를 추가해
    가독성을 높이기 위해 사용합니다

    Args:
        state (AgentState): 에이전트의 현재 state.

    Returns:
        AgentState: 변경되지 않은 state를 반환합니다.
    """
    # 이 함수는 현재 아무 작업도 수행하지 않으며 state를 그대로 반환합니다
    return state

graph_builder.add_conditional_edges(
    'check_helpfulness',
    check_helpfulness_grader,
    {
        'helpful': END,
        'unhelpful': 'rewrite'
    }
)

✏️ 프롬프트 만들기

from langchain_core.prompts import PromptTemplate
from langchain import hub

generate_prompt = hub.pull("rlm/rag-prompt") # 허브에서 가져온 프롬프트

dictionary = ['사람과 관련된 표현 -> 거주자']

rewrite_prompt = PromptTemplate.from_template(f"""
사용자의 질문을 보고, 우리의 사전을 참고해서 사용자의 질문을 변경해주세요 
사전: {dictionary}                                           
질문: {{query}}
""") # 직접 작성하는 프롬프트

출처

PDF 전처리 해보기

Hamp — Sat, 21 Feb 2026 22:52:05 +0900

들어가기 전

인프런 제이쓴님의 강의 코드를 분석하며, 개념을 정리해보자.

학습할 내용

필요한 의존성
새로운 개념
꿀팁

의존성

1. pypdf

랭체인에서 기본적으로 제공하는 PDF 로더가 포함된 패키지
pdf안에 이미지 데이터를 읽지 못하는 단점 존재

2. zerox

llm을 활용하여 ocr을 돌려 문서를 인식하는 패키지
다양한 llm 지원
markdown 형태로 output

ocr이란??

Optical Character Recognitio의 약자
이미지(사진, 스캔 문서) 속에 들어있는 글자를 컴퓨터가 읽을 수 있는 텍스트 데이터로 추출하는 기술

3. UnstructedMarkdownLoader

랭체인에서 제공하는 MarkdownLoader
PDF와 다르게 별도로 split을 해줘야함
정확한 컨텍스트가 전달되지 않을 수 있음
이 때, txt로 변환하는게 안전함
- markdown, html2text, beautifulsoup4 이ㅛ
- markdown -> html -> BeautifulSoup을 이용한 텍스트 추출

4. RecursiveCharacterTextSpliter

문서 split에 사용됨

5.TextLoader

txt 파일 읽기 위한 Loader

⭐ 새로운 개념

1️⃣ Retrieve

LLM이 학습하지 않은 외부 데이터를 찾아오는 과정
RAG의 핵심 패턴

2️⃣ RAG(Retrieval-Augmented Generation, 검색 증강 생성)

LLM이 아는체하며, 환각을 발생시키지 않도록, 신뢰할 수 있는 외부 문서를 찾아보고 답변하는 기술
과정
- Retrieval: 찾아오는 과정
- Augmentation: 찾아온 정보를 사용자의 질문을 하나로 합침
- Generatation: 결합된 정보를 바탕으로 LLM이 최종 답변 생성

3️⃣Vector Store(Vector Database)

유사도 검색에 많이 쓰임
- 사과 -> "빨간 과일", "맛있는 과일", "애플"등 맥락이 비슷한 결과를 함께 찾아줌
문서, 이미지, 음성, 영상 같은데이터를 숫자 배열인 저장하는 특수 저장소
변환 그러면 누가하냐?? 바로 AI모델이 담당함, 이걸 임베딩이라 함 (변환 == 임베딩)
LangGraph에서는 Chroma를 대표적으로 씀

꿀팁

1️⃣ sequence 이용

그래프 형태는 같은데 더 간단히 만들 수 있음

graph_builder 만들 때 add_sequence이용
아래 두 코드가 같은 그래프 형태임

graph_builder.add_node('retrieve', retrieve)
graph_builder.add_node('generate', generate)

from langgraph.graph import START, END

graph_builder.add_edge(START, 'retrieve')
graph_builder.add_edge('retrieve', 'generate')
graph_builder.add_edge('generate', END)
graph = graph_builder.compile()


# ======================== 시퀀스 이용 ========================

sequence_graph_builder = StateGraph(AgentState).add_sequence([retrieve, generate])
sequence_graph_builder.add_edge(START, 'retrieve')
sequence_graph_builder.add_edge('generate', END)
sequence_graph = sequence_graph_builder.compile()

2️⃣ chain

구성 요소

구성 요소	역할	입력 (Input)	출력 (Output)
Prompt	질문 템플릿 생성	딕셔너리 ({var: val})	PromptValue (완성된 문장)
LLM	언어 모델 (뇌)	문장 또는 메시지 목록	BaseMessage (AI의 답변)
Output Parser	답변 정제 (포맷팅)	메시지 또는 문자열	구조화된 데이터 (JSON, List 등)
Retriever	관련 문서 검색	검색어 (String)	문서 목록 (List of Documents)

✏️ 문법

리닉스 파이프라인과 똑같다.

from langchain import hub
from langchain_openai import ChatOpenAI

prompt = hub.pull("rlm/rag-prompt") # https://smith.langchain.com/hub 에서 찾을 수 있다.
llm = ChatOpenAI(model='gpt-4o')


rag_chain = prompt | llm # prompt 아웃풋 -> llm 인풋

출처

https://github.com/jasonkang14/inflearn-langgraph-agent/blob/main/2.2%20%EA%B0%84%EB%8B%A8%ED%95%9C%20Retrieval%20%EC%97%90%EC%9D%B4%EC%A0%84%ED%8A%B8%20(feat.%20PDF%20%EC%A0%84%EC%B2%98%EB%A6%AC%20%EA%BF%80%ED%8C%81).ipynb

inflearn-langgraph-agent/2.2 간단한 Retrieval 에이전트 (feat. PDF 전처리 꿀팁).ipynb at main · jasonkang14/inflearn

인프런의 "LangGraph를 활용한 AI Agent 개발" 강의 소스코드입니다. Contribute to jasonkang14/inflearn-langgraph-agent development by creating an account on GitHub.

github.com