반응형
Agent를 공부해두는 것은 앞으로 미래를 준비하는 관점에서 필수가 될 것으로 보입니다
그래서 조금씩 공부해두고자합니다.
내용은 기업여신 담당자가
선제안할 타겟고객을 도출하는 것으로 하였습니다
파일/내부정보 수집 → 데이터 추출 → 기업별 특징 분석 → 타겟 조건 판단 → 후보 Ranking → 제안 사유 생성 → 결과 저장
특히 중요한 것은 Tool과 Skill을 분리하는 것입니다.
- Tool = Agent가 실제로 실행할 수 있는 기능
- Skill = 여러 Tool을 조합해서 특정 업무를 수행하는 업무능력
- Agent = 어떤 Skill을 언제 사용할지 판단하는 실행 주체
예를 들어 다음과 같은 구조입니다.
Corporate Lending Target Agent
│
├── Agent
│ └── "어떤 기업을 선제안할 것인가?"
│
├── Skills
│ ├── 기업정보 분석 Skill
│ ├── 재무상태 분석 Skill
│ ├── 여신니즈 추정 Skill
│ ├── 타겟고객 선정 Skill
│ └── 제안사유 생성 Skill
│
└── Tools
├── PDF 읽기
├── Excel 읽기
├── DB 조회
├── 기업정보 조회
├── 재무정보 조회
├── 기업간 관계 조회
└── 결과 저장1. 제가 실제 개발한다면 이런 Python 구조로 시작하겠습니다
corporate_lending_agent/
│
├── main.py # Agent 실행 진입점
│
├── agent/
│ └── lending_agent.py # Agent의 판단/오케스트레이션
│
├── skills/
│ ├── document_analysis.py # 문서 분석 Skill
│ ├── financial_analysis.py # 재무 분석 Skill
│ ├── target_selection.py # 타겟 선정 Skill
│ └── proposal_generation.py # 제안사유 생성 Skill
│
├── tools/
│ ├── file_tool.py # 파일 읽기 Tool
│ ├── database_tool.py # 내부 DB 조회 Tool
│ ├── company_tool.py # 기업정보 조회 Tool
│ └── result_tool.py # 결과 저장 Tool
│
├── models/
│ └── company.py # 기업/후보 데이터 구조
│
└── config/
└── config.py여기서 핵심은 Skill을 별도 Python 파일로 만들 수 있다는 것입니다.
즉 질문하셨던 "Skill을 별도 파일로 관리하느냐?"에 대해서는 실무에서는 별도 모듈/파일로 분리하는 것이 훨씬 좋습니다.
2. Tool부터 만들어보겠습니다
예를 들어 Excel, PDF 등의 파일을 읽는 Tool입니다.
# tools/file_tool.py
from pathlib import Path
import pandas as pd
class FileTool:
"""
[TOOL]
Agent가 실제 파일을 읽을 때 사용하는 도구입니다.
Tool은 '무엇을 할 수 있는가'를 정의합니다.
기업여신이라는 업무 자체는 알 필요가 없습니다.
"""
def read_excel(self, file_path: str):
"""
Excel 파일을 읽어서 DataFrame으로 반환
"""
print(f"[Tool] Excel 읽기: {file_path}")
return pd.read_excel(file_path)
def read_text(self, file_path: str):
"""
텍스트 파일 읽기
"""
print(f"[Tool] Text 읽기: {file_path}")
return Path(file_path).read_text(
encoding="utf-8"
)여기까지는 Agent가 아닙니다.
그냥 파일을 읽는 기능입니다.
3. DB 조회 Tool
은행 내부 시스템이라면 실제로는 이런 Tool이 중요합니다.
# tools/database_tool.py
class DatabaseTool:
"""
[TOOL]
은행 내부 DB에서 기업 데이터를 조회하는 Tool
"""
def get_company_financials(self, company_id: str):
print(
f"[Tool] 재무정보 조회: {company_id}"
)
# 실제 환경에서는 SQL/API 호출
return {
"revenue": 1200,
"operating_profit": 120,
"cash": 80,
"debt": 500,
"capex": 300
}
def get_loan_information(self, company_id: str):
print(
f"[Tool] 여신정보 조회: {company_id}"
)
return {
"existing_loan": 400,
"maturity_3months": 200,
"maturity_12months": 300
}
def get_transaction_information(self, company_id: str):
print(
f"[Tool] 거래정보 조회: {company_id}"
)
return {
"deposit": 100,
"fx_transaction": 30,
"card_sales": 20
}실제 은행에서는 여기에
기업기본정보
재무정보
여신정보
예수금
외환
카드
퇴직연금
급여이체
법인카드
무역금융
담보
신용등급
연체정보
한도정보
계열사정보등이 Tool로 연결될 수 있습니다.
4. 그런데 Tool만 있으면 Agent가 아닙니다
여기서 Skill이 등장합니다.
예를 들어
"이 기업이 앞으로 대출을 필요로 할 가능성이 높은가?"
라는 업무를 하나의 Skill로 만듭니다.
# skills/financial_analysis.py
class FinancialAnalysisSkill:
"""
[SKILL]
기업의 재무정보를 분석해서
자금수요 가능성을 판단하는 업무능력입니다.
Skill은 여러 데이터를 조합하여
'업무적인 의미'를 만들어냅니다.
"""
def __init__(self, database_tool):
self.database = database_tool
def analyze(self, company_id):
# -----------------------------------
# [TOOL 호출]
# -----------------------------------
financials = (
self.database
.get_company_financials(company_id)
)
loan = (
self.database
.get_loan_information(company_id)
)
# -----------------------------------
# 재무 분석
# -----------------------------------
revenue = financials["revenue"]
debt = financials["debt"]
capex = financials["capex"]
debt_ratio = debt / revenue
# 만기도래 대출
maturity = loan["maturity_3months"]
# -----------------------------------
# 기업 자금수요 점수
# -----------------------------------
score = 0
if debt_ratio > 0.3:
score += 20
if capex > 200:
score += 30
if maturity > 100:
score += 30
return {
"financial_score": score,
"debt_ratio": debt_ratio,
"maturity_3months": maturity,
"capex": capex
}여기서 아주 중요한 차이가 있습니다.
Tool
DB에서 데이터를 가져온다.Skill
가져온 데이터를 가지고
"자금수요가 있을 가능성이 높다"라는 업무 판단을 한다.5. 기업 타겟 선정 Skill
이제 여러 가지 정보를 종합합니다.
# skills/target_selection.py
class TargetSelectionSkill:
"""
[SKILL]
여러 분석 결과를 종합하여
선제안 대상 기업인지 판단합니다.
"""
def select(self, company, financial_result):
score = 0
# 재무적인 자금수요
score += financial_result["financial_score"]
# --------------------------------
# 기업 성장성
# --------------------------------
if company["revenue_growth"] > 0.15:
score += 20
# --------------------------------
# 기존 은행 거래가 적은 경우
# --------------------------------
if company["bank_share"] < 0.30:
score += 20
# --------------------------------
# 최종 판단
# --------------------------------
if score >= 70:
target = True
else:
target = False
return {
"target": target,
"score": score
}이렇게 하면 단순히
"매출이 큰 기업을 찾아줘"
가 아니라,
예를 들어
A기업
매출 성장률 +20
CAPEX 증가 +30
대출 만기도래 +30
당행 거래비중 낮음 +20
----------------------
Target Score 100처럼 됩니다.
6. 그런데 진짜 Agent는 여기서부터입니다
Agent는 Skill을 순서대로 실행하는 프로그램이 아니라,
상황에 따라 어떤 Tool/Skill을 사용할지를 판단합니다.
간단하게 구현하면 이런 형태입니다.
# agent/lending_agent.py
class LendingAgent:
"""
[AGENT]
기업여신 선제안 업무를 수행하는 Agent
Agent의 역할:
1. 필요한 데이터를 판단
2. 필요한 Tool 호출
3. 필요한 Skill 실행
4. 결과 종합
"""
def __init__(
self,
file_tool,
database_tool,
financial_skill,
target_skill
):
self.file_tool = file_tool
self.database = database_tool
self.financial_skill = financial_skill
self.target_skill = target_skill
def run(self, companies):
results = []
# 기업별 분석
for company in companies:
company_id = company["company_id"]
print(
f"\n[Agent] {company_id} 분석 시작"
)
# -----------------------------
# Skill 1
# 재무분석
# -----------------------------
financial_result = (
self.financial_skill
.analyze(company_id)
)
# -----------------------------
# Skill 2
# 타겟선정
# -----------------------------
target_result = (
self.target_skill
.select(
company,
financial_result
)
)
# -----------------------------
# 결과 저장
# -----------------------------
results.append({
"company_id": company_id,
"score": target_result["score"],
"target": target_result["target"]
})
return results이 정도가 가장 기본적인 Agent 구조입니다.
7. 실제 실행 코드
# main.py
from tools.file_tool import FileTool
from tools.database_tool import DatabaseTool
from skills.financial_analysis import (
FinancialAnalysisSkill
)
from skills.target_selection import (
TargetSelectionSkill
)
from agent.lending_agent import LendingAgent
# ==========================================
# 1. Tool 생성
# ==========================================
file_tool = FileTool()
database_tool = DatabaseTool()
# ==========================================
# 2. Skill 생성
# ==========================================
financial_skill = (
FinancialAnalysisSkill(
database_tool
)
)
target_skill = (
TargetSelectionSkill()
)
# ==========================================
# 3. Agent 생성
# ==========================================
agent = LendingAgent(
file_tool=file_tool,
database_tool=database_tool,
financial_skill=financial_skill,
target_skill=target_skill
)
# ==========================================
# 4. 분석 대상 기업
# ==========================================
companies = [
{
"company_id": "A001",
"name": "ABC전자",
"revenue_growth": 0.25,
"bank_share": 0.20
},
{
"company_id": "A002",
"name": "XYZ화학",
"revenue_growth": 0.05,
"bank_share": 0.60
}
]
# ==========================================
# 5. Agent 실행
# ==========================================
results = agent.run(companies)
print("\n===== 최종 Target =====")
for result in results:
if result["target"]:
print(
result["company_id"],
result["score"]
)이것이 질문하신 "실제로 Agent 개발자가 작성하는 코드가 어떤 모습인가?"에 대한 가장 단순한 형태입니다.
8. 실제 프로젝트에서는 LLM이 중간에 들어갑니다
지금 코드에는 아직 LLM이 없습니다.
실제 기업여신 Agent라면 저는 다음과 같이 만들겠습니다.
┌───────────────────┐
│ Corporate Agent │
└─────────┬─────────┘
│
"무슨 정보를 볼까?"
│
┌───────────────────┼───────────────────┐
↓ ↓ ↓
기업정보 Tool 재무정보 Tool 문서 Tool
│ │ │
↓ ↓ ↓
기업정보 재무정보 PDF/Excel
└───────────────────┼───────────────────┘
↓
┌─────────────────┐
│ LLM 분석 │
└────────┬────────┘
↓
Financial Skill
↓
Demand Skill
↓
Target Skill
↓
Ranking
↓
Proposal Generation예를 들어 PDF에
"2027년 생산설비 500억원 증설 예정"
이라는 내용이 있다면 LLM이 이것을 단순 텍스트가 아니라
{
"event": "CAPEX",
"amount": 50000000000,
"expected_date": "2027",
"financing_need": "HIGH"
}처럼 구조화할 수 있습니다.
그리고 내부 DB의
매출 2,000억
현금 100억
기존대출 500억
당행대출 100억과 결합합니다.
그러면 Agent가 최종적으로
[선제안 후보]
기업명: ABC전자
Target Score: 91
주요 근거
1. 2027년 500억원 설비투자 예정
2. 최근 3년 매출 CAGR 18%
3. 보유현금 대비 투자규모가 큼
4. 기존 차입금 만기 도래
5. 당행 거래비중 15%로 낮음
예상 니즈
→ 시설자금
→ 운전자금
→ 외환
→ 기업금융 확대
추천 제안
→ 시설자금 300억원
→ 운전자금 한도 100억원
→ 환율/수입결제 패키지까지 만들 수 있습니다.
9. 이 부분에서 "Agent"와 기존 프로그램의 차이가 생깁니다
전통적인 프로그램이라면
if capex > 300:
score += 30
if revenue_growth > 0.15:
score += 20처럼 사람이 미리 규칙을 만들어야 합니다.
Agent 방식에서는
PDF
+
공시
+
재무제표
+
뉴스
+
은행 내부정보
+
거래정보를 LLM이 읽고
"이 회사가 앞으로 자금이 필요할 이유가 무엇인가?"를 추론하게 할 수 있습니다.
다만 최종 신용판단을 LLM에게 맡기면 안 됩니다.
좋은 구조는
LLM → 정보 추출/해석/가설 생성
Rule/SQL/ML → 수치 계산 및 검증
Agent → 전체 프로세스 orchestration
Human → 최종 영업/여신 판단입니다.
10. 실제 은행 프로젝트라면 Skill은 이렇게 세분화할 것 같습니다
skills/
01_document_analysis.py
↓
공시/보고서/PDF 분석
02_company_analysis.py
↓
기업 기본정보 분석
03_financial_analysis.py
↓
재무상태 분석
04_cashflow_analysis.py
↓
현금흐름 분석
05_loan_analysis.py
↓
기존 여신 분석
06_transaction_analysis.py
↓
당행 거래 분석
07_industry_analysis.py
↓
산업/시장 분석
08_funding_need_prediction.py
↓
자금수요 예측
09_target_selection.py
↓
타겟기업 선정
10_proposal_generation.py
↓
상품/제안내용 생성이렇게 하면 나중에
"자금수요 예측 방식만 바꿔주세요."
라고 했을 때 funding_need_prediction.py만 수정하면 됩니다.
11. Tool은 더 아래 레벨입니다
예를 들어 Skill이
funding_need_prediction()이라고 한다면 내부적으로는
funding_need_prediction Skill
│
├── get_financial_data()
├── get_loan_data()
├── get_transaction_data()
├── search_company_news()
├── read_disclosure()
└── LLM 분석을 호출합니다.
즉 구조적으로는
Agent
↓
Skill
↓
Tool
↓
Data/API/DB라고 이해하시면 상당히 정확합니다.
12. 한 명이 개발한다면 얼마나 걸릴까?
여기서는 범위를 어떻게 잡느냐가 굉장히 중요합니다.
제가 1인 개발 기준으로 현실적으로 예상하면 다음 정도입니다.
단계개발 내용1인 예상
| PoC | PDF/Excel → 기업 후보 | 1~2주 |
| MVP | 내부 DB + LLM + 후보 Ranking | 4~6주 |
| Pilot | 5~10개 Skill + Agent | 8~12주 |
| 업무용 | 보안/로그/권한/검증 포함 | 4~6개월 |
| 은행 운영계 | WAS/API/모니터링/감사로그/권한/장애대응 | 6~12개월+ |
제가 질문하신 상황이라면 1차 목표를 8~12주로 잡겠습니다.
단, 여기서 중요한 전제가 있습니다.
1인 개발자가 할 수 있는 8~12주짜리 MVP
PDF
Excel
CSV
↓
Document Parser
↓
LLM
↓
기업정보 분석
↓
재무 분석
↓
자금수요 추정
↓
Target Score
↓
상위 20개 기업
↓
제안사유 생성정도입니다.
13. 은행 시스템과 연결하면 이야기가 달라집니다
예를 들어 실제 은행의
여신계
고객정보계
정보계
기업정보
신용평가
상품계
CRM
뉴스
공시를 연결하고,
Agent 화면까지 만들어야 한다면 1명이 하기에는 상당히 커집니다.
대략
Agent/LLM 개발 1명
Backend/API 1명
Frontend 1명
Data/SQL 1명
인프라/보안 0.5~1명
현업/기획 1명정도가 현실적입니다.
즉 "Agent 자체를 만드는 것"은 생각보다 빠르지만, "은행에서 실제 사용할 수 있는 Agent 시스템"을 만드는 것은 훨씬 큰 프로젝트입니다.
14. 제가 이 프로젝트를 한다면 12주를 이렇게 나눕니다
1~2주
│
├─ 데이터 정의
├─ Target 고객 정의
├─ Tool 인터페이스
└─ LLM/RAG 구조
3~4주
│
├─ PDF/Excel Parser
├─ DB Tool
├─ 기업정보 Tool
└─ Document Analysis Skill
5~6주
│
├─ Financial Analysis Skill
├─ Loan Analysis Skill
└─ Funding Need Skill
7~8주
│
├─ Target Selection
├─ Scoring
├─ Ranking
└─ 근거 생성
9~10주
│
├─ Proposal Generation
├─ Agent Orchestration
└─ Agent 화면/API
11주
│
├─ 정확도 검증
├─ Hallucination 방지
└─ 현업 테스트
12주
│
├─ 성능 개선
├─ 로그
└─ Pilot그리고 가장 중요한 개발 포인트는 LLM 자체가 아닙니다.
오히려
"어떤 기업을 좋은 선제안 고객이라고 정의할 것인가?"
를 먼저 정하는 것이 핵심입니다.
예를 들어
Target Score
성장성 20%
자금수요 30%
기존여신 만기도래 15%
당행 거래잠재력 15%
수익성 10%
산업전망 10%처럼 업무적인 Target Definition을 먼저 만들고, Agent가 그것을 자동화하도록 만드는 것이 좋습니다.
특히 기업여신에서는 "좋은 기업을 찾는 Agent"보다 "3~12개월 안에 특정 금융 니즈가 발생할 가능성이 높은 기업을 찾는 Agent"로 정의하는 것이 훨씬 강력합니다.
예를 들어 CAPEX 증가 → 시설자금, 수출 증가 → 무역금융/FX, M&A 추진 → 인수금융, 매출 급증 → 운전자금, 타행 대출 만기도래 → 대환/신규여신처럼 기업의 이벤트를 금융상품 니즈로 변환하는 구조를 넣으면 실제 영업 현장에서 활용도가 크게 올라갑니다.
반응형