LangFlow 완전 가이드 3편 — 심화 튜토리얼 : 에이전트, 메모리, 커스텀 컴포넌트

2편에서 기본 챗봇과 PDF RAG를 만들었어요.

이번 편은 진짜 쓸만한 걸 만들어요.

이번 편에서 만드는 것:
1. 대화 메모리 챗봇 — 이전 대화 기억
2. 웹 검색 에이전트 — 실시간 정보 검색
3. 툴 조합 에이전트 — 검색 + 계산 + URL 읽기
4. 커스텀 Python 컴포넌트 — 내가 원하는 기능 직접 만들기
5. 조건 분기 플로우 — If/Else 로직

---

실전 1 — 대화 메모리 챗봇

기본 챗봇의 문제점:

사용자: 내 이름은 셀이야
Claude: 안녕하세요, 셀님!

사용자: 내 이름이 뭐야?
Claude: 죄송합니다. 이전 대화 내용을 기억하지 못합니다.

메모리를 붙이면 해결돼요.

방법 1 — Agent 컴포넌트 사용 (가장 간단)

Agent 컴포넌트는 메모리가 기본으로 내장돼 있어요.

컴포넌트:

1. Chat Input
2. Agent        ← 메모리 내장
3. Chat Output

연결:

[Chat Input] ──→ [Agent] ──→ [Chat Output]

Agent 컴포넌트 설정:

Model Provider: Anthropic
Model Name:     claude-sonnet-4-6
API Key:        ANTHROPIC_API_KEY

Agent Instructions:
"당신은 친절한 AI 어시스턴트입니다.
이전 대화 내용을 기억하고 활용하세요."

Number of Chat History Messages: 10  ← 몇 개의 이전 메시지 기억할지

테스트:

[1번 메시지] 내 이름은 셀이야
[응답] 안녕하세요, 셀님!

[2번 메시지] 내 이름이 뭐야?
[응답] 셀님이세요! 아까 알려주셨잖아요.

방법 2 — Message History 컴포넌트 (세밀한 제어)

Language Model 컴포넌트 쓸 때 (Agent 아닐 때) 필요해요.

컴포넌트:

1. Chat Input
2. Message History (Retrieve 모드)  ← 이전 대화 불러오기
3. Prompt Template
4. Language Model
5. Chat Output
6. Message History (Store 모드)     ← 현재 대화 저장

연결:

[Chat Input] ──────────────────────────────→ [Prompt Template] ──→ [Language Model] ──→ [Chat Output]
                                                     ↑                                         │
[Message History (Retrieve)] ─────────────→ {memory}                                         │
                                                                                               │
                                                                              [Message History (Store)] ←─┘

Message History 컴포넌트 설정:

Mode: Retrieve    (첫 번째 컴포넌트)
Session ID:       {session_id}  ← 사용자별 대화 분리
Order:            Ascending
Number of Messages: 10

Prompt Template:

당신은 친절한 AI 어시스턴트입니다.

이전 대화 내용:
{memory}

현재 질문: {user_input}

---

실전 2 — 웹 검색 에이전트

실시간 정보를 검색해서 답하는 에이전트예요.

컴포넌트

1. Chat Input
2. Agent
3. Search API Tool  (DuckDuckGo 또는 SerpAPI)
4. Chat Output

연결

[Chat Input] ──→ [Agent] ──→ [Chat Output]
                    ↑
              [Search Tool]

Search Tool을 Agent의 Tools 포트에 연결해요.

Agent 설정

Model Provider: Anthropic
Model Name:     claude-sonnet-4-6

Agent Instructions:
"당신은 최신 정보를 검색해서 답하는 리서치 어시스턴트입니다.
항상 검색 툴을 사용해서 최신 정보를 확인하고 답하세요.
검색 결과 출처를 명시하세요."

Max Iterations: 5

DuckDuckGo 툴 (무료, API 키 불필요)

사이드바에서 검색:

"DuckDuckGo" 검색
→ DuckDuckGo Search 컴포넌트 드래그
→ Agent의 Tools 포트에 연결

설정:

Max Results: 5
Backend: api

테스트

"Claude Opus 4.7 출시일이 언제야?"
→ 에이전트가 DuckDuckGo 검색 실행
→ 검색 결과 분석
→ 정확한 날짜 답변

"오늘 비트코인 가격이 얼마야?"
→ 실시간 검색 후 답변

---

실전 3 — 툴 조합 에이전트

검색 + URL 읽기 + 계산을 동시에 쓰는 에이전트예요.

컴포넌트

1. Chat Input
2. Agent
3. DuckDuckGo Search  ← 웹 검색
4. URL Tool           ← 특정 URL 내용 읽기
5. Calculator         ← 수학 계산
6. Chat Output

연결

[Chat Input] ──→ [Agent] ──→ [Chat Output]
                    ↑
         [DuckDuckGo Search]
         [URL Tool]
         [Calculator]

세 가지 툴 모두 Agent의 Tools 포트에 연결해요.

한 Agent에 여러 툴을 붙이면 상황에 따라 알아서 적절한 툴을 선택해요.

Agent Instructions

당신은 다목적 리서치 어시스턴트입니다.

사용 가능한 툴:
- 웹 검색: 최신 정보, 뉴스 검색
- URL 읽기: 특정 웹페이지 내용 분석
- 계산기: 수학 계산, 환율 계산 등

질문 유형에 따라 적절한 툴을 선택하세요.
여러 툴을 조합해서 더 정확한 답변을 제공하세요.

테스트

"OpenAI의 최신 모델 가격을 검색하고
100만 토큰 사용 시 예상 비용을 계산해줘"

→ 에이전트 실행 순서:
1. DuckDuckGo로 GPT-5.4 가격 검색
2. 검색 결과에서 가격 추출
3. Calculator로 100만 토큰 비용 계산
4. 종합 답변 생성

---

실전 4 — 커스텀 Python 컴포넌트

기본 제공 컴포넌트로 안 되는 기능을 직접 만들어요.

예시 1 — 한국어 감정 분석 컴포넌트

사이드바 하단 → "+ Custom Component" 클릭
→ Code 편집창 열림

다음 코드 입력:

from langflow.custom import Component
from langflow.io import MessageTextInput, Output
from langflow.schema import Data

class KoreanSentimentAnalyzer(Component):
    display_name = "한국어 감정 분석"
    description = "한국어 텍스트의 감정을 분석합니다 (긍정/부정/중립)"
    icon = "😊"

    inputs = [
        MessageTextInput(
            name="text",
            display_name="분석할 텍스트",
            info="감정을 분석할 한국어 텍스트를 입력하세요"
        ),
    ]

    outputs = [
        Output(
            display_name="분석 결과",
            name="result",
            method="analyze_sentiment"
        ),
    ]

    def analyze_sentiment(self) -> Data:
        text = self.text

        # 간단한 키워드 기반 감정 분석
        positive_words = ["좋아", "최고", "훌륭", "감사", "행복", "멋지다", "좋다", "잘했어"]
        negative_words = ["싫어", "최악", "나쁘다", "화났어", "실망", "짜증", "별로", "못했어"]

        text_lower = text.lower()
        pos_count = sum(1 for w in positive_words if w in text_lower)
        neg_count = sum(1 for w in negative_words if w in text_lower)

        if pos_count > neg_count:
            sentiment = "긍정 😊"
            score = pos_count / (pos_count + neg_count)
        elif neg_count > pos_count:
            sentiment = "부정 😞"
            score = neg_count / (pos_count + neg_count)
        else:
            sentiment = "중립 😐"
            score = 0.5

        result = {
            "text": text,
            "sentiment": sentiment,
            "confidence": f"{score:.0%}",
            "positive_keywords": pos_count,
            "negative_keywords": neg_count,
        }

        return Data(data=result)

Save 클릭 → 캔버스에 컴포넌트 자동 추가.

예시 2 — DB 조회 컴포넌트

실제 데이터베이스에서 정보를 가져오는 컴포넌트예요.

from langflow.custom import Component
from langflow.io import MessageTextInput, SecretStrInput, Output
from langflow.schema import Data
import psycopg2
import json

class PostgreSQLQueryComponent(Component):
    display_name = "PostgreSQL 조회"
    description = "PostgreSQL 데이터베이스에서 데이터를 조회합니다"
    icon = "🗄️"

    inputs = [
        SecretStrInput(
            name="connection_string",
            display_name="Connection String",
            info="postgresql://user:pass@host:port/dbname"
        ),
        MessageTextInput(
            name="query",
            display_name="SQL 쿼리",
            info="실행할 SELECT 쿼리"
        ),
    ]

    outputs = [
        Output(
            display_name="조회 결과",
            name="result",
            method="execute_query"
        ),
    ]

    def execute_query(self) -> Data:
        try:
            conn = psycopg2.connect(self.connection_string)
            cursor = conn.cursor()

            # SELECT만 허용 (보안)
            query = self.query.strip()
            if not query.upper().startswith("SELECT"):
                return Data(data={"error": "SELECT 쿼리만 허용됩니다"})

            cursor.execute(query)
            columns = [desc[0] for desc in cursor.description]
            rows = cursor.fetchall()

            result = [dict(zip(columns, row)) for row in rows]

            cursor.close()
            conn.close()

            return Data(data={
                "rows": result,
                "count": len(result),
                "columns": columns,
            })

        except Exception as e:
            return Data(data={"error": str(e)})

커스텀 컴포넌트를 에이전트 툴로 사용

커스텀 컴포넌트도 에이전트 툴로 쓸 수 있어요.

커스텀 컴포넌트 클릭
→ 상단 메뉴 → "Tool Mode" 활성화
→ Agent의 Tools 포트에 연결

이제 에이전트가 알아서 언제 이 툴을 쓸지 판단해요.

사용자: "우리 DB에서 오늘 주문 건수 알려줘"
에이전트: PostgreSQL 조회 툴 실행 →
         SELECT COUNT(*) FROM orders WHERE date = CURRENT_DATE →
         결과 반환 → 답변 생성

---

실전 5 — 조건 분기 플로우

질문 유형에 따라 다른 경로로 처리해요.

구조

사용자 질문
    ↓
[분류기] ← 질문 유형 판단
    ├── 코딩 질문 → [코딩 전문 Agent]
    ├── 일반 질문 → [일반 챗봇]
    └── 문서 검색 → [RAG 파이프라인]

컴포넌트

1. Chat Input
2. Language Model (분류용)
3. Conditional Router  ← 조건 분기 컴포넌트
4. Agent (코딩 전문)
5. Language Model (일반)
6. Chroma DB + Language Model (RAG)
7. Chat Output

분류용 Language Model 설정

System Prompt:
"다음 질문을 분류해줘. 반드시 아래 중 하나만 답해:
- coding
- general
- document

질문이 코드 작성, 디버깅, 프로그래밍이면: coding
질문이 문서, 파일, 업로드된 내용이면: document
그 외 모든 질문: general"

Temperature: 0  ← 일관된 분류를 위해 0

Conditional Router 설정

컴포넌트 클릭:

Condition 1:
  Input:    (분류 결과)
  Operator: equals
  Value:    coding
  Route to: Agent (코딩 전문)

Condition 2:
  Input:    (분류 결과)
  Operator: equals
  Value:    document
  Route to: RAG 파이프라인

Default:
  Route to: 일반 Language Model

테스트

"FastAPI로 JWT 인증 만들어줘"
→ 분류기: coding
→ 코딩 전문 에이전트 실행
→ 상세한 코드 + 설명

"날씨가 어때?"
→ 분류기: general
→ 일반 챗봇 응답

"업로드한 계약서에서 조항 찾아줘"
→ 분류기: document
→ RAG 파이프라인 실행

---

컴포넌트 그룹핑

복잡한 플로우가 길어지면 관련 컴포넌트를 그룹으로 묶어요.

Shift + 드래그로 여러 컴포넌트 선택
→ "Group" 버튼 클릭
→ 하나의 블록으로 합쳐짐

예:
[Split Text + Embeddings + Chroma] → [RAG 파이프라인] 그룹으로

그룹을 만들면 캔버스가 훨씬 깔끔해지고, 다른 플로우에서 재사용할 수 있어요.

---

플로우 내보내기 / 가져오기

만든 플로우를 JSON으로 저장하고 공유해요.

우상단 메뉴 → Export
→ JSON 파일 다운로드

가져오기:
메인 화면 → Import
→ JSON 파일 선택
→ 플로우 복원

팀원에게 플로우 파일을 공유하거나 Git으로 버전 관리도 가능해요.

---

4편 예고

4편 — 심화 튜토리얼 2:
- 멀티 에이전트 파이프라인 (에이전트가 에이전트를 툴로 사용)
- MCP 서버 연결 (Claude Desktop, GitHub, Slack)
- 프로덕션 배포 (Docker + PostgreSQL)
- LangFlow API로 외부 앱에 완전 통합
- 모니터링 및 트레이싱

---

 

📌 이전 글: LangFlow 2편 — 챗봇부터 PDF RAG까지</a>

LangFlow 완전 가이드 2편 — 기본 튜토리얼 : 챗봇부터 PDF RAG까지

📌 다음 글: LangFlow 4편 — 멀티 에이전트, MCP, 프로덕션 배포

LangFlow 완전 가이드 4편 — 심화 튜토리얼 2 : 멀티 에이전트, MCP, 프로덕션 배포