15_agent_tools.py

  1"""
  215. LLM 에이전트 (LLM Agents) 예제
  3
  4ReAct 패턴, Tool Use, LangChain Agent 실습
  5"""
  6
  7import json
  8import re
  9from typing import Dict, List, Callable, Any
 10
 11print("=" * 60)
 12print("LLM 에이전트 (LLM Agents)")
 13print("=" * 60)
 14
 15
 16# ============================================
 17# 1. 도구 정의
 18# ============================================
 19print("\n[1] 도구 (Tools) 정의")
 20print("-" * 40)
 21
 22class Tool:
 23    """도구 기본 클래스"""
 24
 25    def __init__(self, name: str, description: str, func: Callable):
 26        self.name = name
 27        self.description = description
 28        self.func = func
 29
 30    def run(self, input_str: str) -> str:
 31        """도구 실행"""
 32        try:
 33            return str(self.func(input_str))
 34        except Exception as e:
 35            return f"Error: {str(e)}"
 36
 37
 38# 도구 구현
 39def calculator(expression: str) -> float:
 40    """안전한 수학 계산"""
 41    # 간단한 안전 체크
 42    allowed_chars = set("0123456789+-*/.() ")
 43    if not all(c in allowed_chars for c in expression):
 44        raise ValueError("Invalid characters in expression")
 45    return eval(expression)
 46
 47def search(query: str) -> str:
 48    """검색 시뮬레이션"""
 49    # 실제로는 API 호출
 50    results = {
 51        "파이썬 창시자": "파이썬은 1991년 귀도 반 로섬(Guido van Rossum)이 개발했습니다.",
 52        "인공지능": "인공지능(AI)은 인간의 지능을 모방하는 컴퓨터 시스템입니다.",
 53        "서울 인구": "서울의 인구는 약 950만 명입니다 (2024년 기준).",
 54    }
 55    for key, value in results.items():
 56        if key in query:
 57            return value
 58    return f"'{query}'에 대한 검색 결과를 찾을 수 없습니다."
 59
 60def get_weather(city: str) -> str:
 61    """날씨 조회 시뮬레이션"""
 62    weather_data = {
 63        "서울": {"temp": 25, "condition": "맑음"},
 64        "부산": {"temp": 28, "condition": "흐림"},
 65        "제주": {"temp": 27, "condition": "구름 조금"},
 66    }
 67    if city in weather_data:
 68        data = weather_data[city]
 69        return f"{city} 날씨: {data['temp']}도, {data['condition']}"
 70    return f"{city}의 날씨 정보를 찾을 수 없습니다."
 71
 72
 73# 도구 등록
 74tools = [
 75    Tool("calculator", "수학 계산. 입력: 수학 표현식 (예: '2 + 3 * 4')", calculator),
 76    Tool("search", "정보 검색. 입력: 검색어", search),
 77    Tool("get_weather", "날씨 조회. 입력: 도시 이름", get_weather),
 78]
 79
 80print("사용 가능한 도구:")
 81for tool in tools:
 82    print(f"  - {tool.name}: {tool.description}")
 83
 84
 85# ============================================
 86# 2. ReAct 패턴 시뮬레이션
 87# ============================================
 88print("\n[2] ReAct 패턴 시뮬레이션")
 89print("-" * 40)
 90
 91class ReActAgent:
 92    """ReAct (Reasoning + Acting) 에이전트"""
 93
 94    def __init__(self, tools: List[Tool]):
 95        self.tools = {t.name: t for t in tools}
 96        self.history = []
 97
 98    def think(self, question: str, observations: List[str]) -> Dict[str, str]:
 99        """
100        생각 단계 (실제로는 LLM 호출)
101        여기서는 규칙 기반으로 시뮬레이션
102        """
103        question_lower = question.lower()
104
105        # 규칙 기반 의사결정 (실제로는 LLM이 수행)
106        if "날씨" in question_lower:
107            # 도시 추출
108            cities = ["서울", "부산", "제주"]
109            for city in cities:
110                if city in question:
111                    return {
112                        "thought": f"{city}의 날씨를 확인해야 합니다.",
113                        "action": "get_weather",
114                        "action_input": city
115                    }
116
117        if "계산" in question_lower or any(op in question for op in ["+", "-", "*", "/"]):
118            # 수식 추출
119            numbers = re.findall(r'[\d\+\-\*\/\.\(\)\s]+', question)
120            if numbers:
121                expr = numbers[0].strip()
122                return {
123                    "thought": f"'{expr}'을 계산해야 합니다.",
124                    "action": "calculator",
125                    "action_input": expr
126                }
127
128        if any(keyword in question_lower for keyword in ["누구", "무엇", "어디", "검색"]):
129            return {
130                "thought": f"'{question}'에 대해 검색해야 합니다.",
131                "action": "search",
132                "action_input": question
133            }
134
135        # 이미 충분한 정보가 있으면 최종 답변
136        if observations:
137            return {
138                "thought": "충분한 정보를 수집했습니다.",
139                "final_answer": " ".join(observations)
140            }
141
142        return {
143            "thought": "질문을 이해하지 못했습니다.",
144            "final_answer": "죄송합니다, 질문을 처리할 수 없습니다."
145        }
146
147    def act(self, action: str, action_input: str) -> str:
148        """행동 단계"""
149        if action in self.tools:
150            return self.tools[action].run(action_input)
151        return f"Error: Unknown tool '{action}'"
152
153    def run(self, question: str, max_steps: int = 5) -> str:
154        """에이전트 실행"""
155        observations = []
156
157        print(f"\n질문: {question}")
158        print("-" * 30)
159
160        for step in range(max_steps):
161            # 생각
162            result = self.think(question, observations)
163
164            print(f"\n[Step {step + 1}]")
165            print(f"Thought: {result.get('thought', '')}")
166
167            # 최종 답변 확인
168            if "final_answer" in result:
169                print(f"Final Answer: {result['final_answer']}")
170                return result["final_answer"]
171
172            # 행동
173            action = result.get("action")
174            action_input = result.get("action_input")
175
176            if action:
177                print(f"Action: {action}")
178                print(f"Action Input: {action_input}")
179
180                observation = self.act(action, action_input)
181                observations.append(observation)
182                print(f"Observation: {observation}")
183
184        return "최대 단계 도달"
185
186
187# 테스트
188agent = ReActAgent(tools)
189
190questions = [
191    "서울 날씨 어때?",
192    "15 + 27 * 3을 계산해줘",
193    "파이썬 창시자가 누구야?",
194]
195
196for q in questions:
197    result = agent.run(q)
198
199
200# ============================================
201# 3. Function Calling 형식
202# ============================================
203print("\n" + "=" * 60)
204print("[3] Function Calling 형식")
205print("-" * 40)
206
207# OpenAI Function Calling 형식
208function_definitions = [
209    {
210        "type": "function",
211        "function": {
212            "name": "get_weather",
213            "description": "특정 도시의 현재 날씨 정보를 가져옵니다.",
214            "parameters": {
215                "type": "object",
216                "properties": {
217                    "city": {
218                        "type": "string",
219                        "description": "도시 이름 (예: Seoul, Tokyo)"
220                    },
221                    "unit": {
222                        "type": "string",
223                        "enum": ["celsius", "fahrenheit"],
224                        "description": "온도 단위"
225                    }
226                },
227                "required": ["city"]
228            }
229        }
230    },
231    {
232        "type": "function",
233        "function": {
234            "name": "search_web",
235            "description": "웹에서 정보를 검색합니다.",
236            "parameters": {
237                "type": "object",
238                "properties": {
239                    "query": {
240                        "type": "string",
241                        "description": "검색어"
242                    }
243                },
244                "required": ["query"]
245            }
246        }
247    }
248]
249
250print("Function Calling 정의:")
251print(json.dumps(function_definitions, indent=2, ensure_ascii=False))
252
253
254# ============================================
255# 4. 멀티 에이전트 시뮬레이션
256# ============================================
257print("\n" + "=" * 60)
258print("[4] 멀티 에이전트 시뮬레이션")
259print("-" * 40)
260
261class ResearcherAgent:
262    """연구 에이전트"""
263
264    def __init__(self):
265        self.name = "Researcher"
266
267    def research(self, topic: str) -> str:
268        """주제 연구 (시뮬레이션)"""
269        research_db = {
270            "인공지능": "AI는 1956년 다트머스 회의에서 시작되었으며, "
271                       "머신러닝, 딥러닝, 자연어처리 등으로 발전했습니다.",
272            "파이썬": "파이썬은 1991년 귀도 반 로섬이 개발한 프로그래밍 언어로, "
273                     "간결한 문법과 풍부한 라이브러리가 특징입니다.",
274        }
275        for key, value in research_db.items():
276            if key in topic:
277                return value
278        return f"{topic}에 대한 연구 결과를 찾을 수 없습니다."
279
280
281class WriterAgent:
282    """작문 에이전트"""
283
284    def __init__(self):
285        self.name = "Writer"
286
287    def write(self, research_results: str, style: str = "formal") -> str:
288        """문서 작성 (시뮬레이션)"""
289        if style == "formal":
290            return f"## 연구 보고서\n\n{research_results}\n\n본 내용은 연구 결과를 바탕으로 작성되었습니다."
291        else:
292            return f"# 요약\n\n{research_results}"
293
294
295class ReviewerAgent:
296    """검토 에이전트"""
297
298    def __init__(self):
299        self.name = "Reviewer"
300
301    def review(self, document: str) -> str:
302        """문서 검토 (시뮬레이션)"""
303        issues = []
304        if len(document) < 100:
305            issues.append("내용이 너무 짧습니다.")
306        if "참고문헌" not in document:
307            issues.append("참고문헌이 없습니다.")
308
309        if issues:
310            return "검토 결과:\n" + "\n".join(f"- {issue}" for issue in issues)
311        return "검토 결과: 수정 필요 없음"
312
313
314class MultiAgentSystem:
315    """멀티 에이전트 시스템"""
316
317    def __init__(self):
318        self.researcher = ResearcherAgent()
319        self.writer = WriterAgent()
320        self.reviewer = ReviewerAgent()
321
322    def create_document(self, topic: str) -> str:
323        """문서 생성 파이프라인"""
324        print(f"\n토픽: {topic}")
325
326        # 1. 연구
327        print(f"\n[{self.researcher.name}] 연구 중...")
328        research = self.researcher.research(topic)
329        print(f"연구 결과: {research[:50]}...")
330
331        # 2. 작성
332        print(f"\n[{self.writer.name}] 작성 중...")
333        document = self.writer.write(research)
334        print(f"작성 결과: {document[:50]}...")
335
336        # 3. 검토
337        print(f"\n[{self.reviewer.name}] 검토 중...")
338        review = self.reviewer.review(document)
339        print(f"검토 결과: {review}")
340
341        return document
342
343
344# 테스트
345system = MultiAgentSystem()
346doc = system.create_document("인공지능의 역사")
347print(f"\n최종 문서:\n{doc}")
348
349
350# ============================================
351# 5. LangChain Agent 코드 예시
352# ============================================
353print("\n" + "=" * 60)
354print("[5] LangChain Agent 코드 예시")
355print("-" * 40)
356
357langchain_code = '''
358from langchain_openai import ChatOpenAI
359from langchain.agents import AgentExecutor, create_openai_tools_agent
360from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
361from langchain.tools import tool
362
363# LLM
364llm = ChatOpenAI(model="gpt-4", temperature=0)
365
366# 도구 정의
367@tool
368def calculator(expression: str) -> str:
369    """수학 계산. 입력: 수학 표현식 (예: '2 + 3 * 4')"""
370    return str(eval(expression))
371
372@tool
373def get_current_time() -> str:
374    """현재 시간 반환"""
375    from datetime import datetime
376    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
377
378tools = [calculator, get_current_time]
379
380# 프롬프트
381prompt = ChatPromptTemplate.from_messages([
382    ("system", "당신은 도움이 되는 AI입니다."),
383    MessagesPlaceholder(variable_name="chat_history", optional=True),
384    ("human", "{input}"),
385    MessagesPlaceholder(variable_name="agent_scratchpad"),
386])
387
388# 에이전트 생성
389agent = create_openai_tools_agent(llm, tools, prompt)
390agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
391
392# 실행
393result = agent_executor.invoke({"input": "현재 시간과 15 + 27의 결과를 알려줘"})
394print(result["output"])
395'''
396print(langchain_code)
397
398
399# ============================================
400# 6. 자율 에이전트 (AutoGPT 스타일)
401# ============================================
402print("\n" + "=" * 60)
403print("[6] 자율 에이전트 (AutoGPT 스타일)")
404print("-" * 40)
405
406class AutoGPTLikeAgent:
407    """AutoGPT 스타일 자율 에이전트"""
408
409    def __init__(self, tools: List[Tool], goals: List[str]):
410        self.tools = {t.name: t for t in tools}
411        self.goals = goals
412        self.memory = []
413        self.completed_tasks = []
414
415    def plan(self) -> Dict[str, Any]:
416        """다음 작업 계획 (규칙 기반 시뮬레이션)"""
417        # 아직 달성하지 않은 목표 확인
418        remaining_goals = [g for g in self.goals if g not in self.completed_tasks]
419
420        if not remaining_goals:
421            return {"task": "COMPLETE", "summary": "모든 목표 달성!"}
422
423        current_goal = remaining_goals[0]
424
425        # 간단한 규칙 기반 계획
426        if "날씨" in current_goal:
427            return {
428                "task": current_goal,
429                "tool": "get_weather",
430                "input": "서울"
431            }
432        elif "계산" in current_goal or "숫자" in current_goal:
433            return {
434                "task": current_goal,
435                "tool": "calculator",
436                "input": "100 + 200"
437            }
438        else:
439            return {
440                "task": current_goal,
441                "tool": "search",
442                "input": current_goal
443            }
444
445    def execute(self, plan: Dict[str, Any]) -> Dict[str, Any]:
446        """계획 실행"""
447        if plan.get("task") == "COMPLETE":
448            return {"status": "complete", "summary": plan["summary"]}
449
450        tool_name = plan.get("tool")
451        tool_input = plan.get("input")
452
453        if tool_name in self.tools:
454            result = self.tools[tool_name].run(tool_input)
455            return {"status": "success", "result": result}
456
457        return {"status": "error", "message": f"Unknown tool: {tool_name}"}
458
459    def run(self, max_iterations: int = 5) -> str:
460        """에이전트 실행"""
461        print(f"\n목표: {self.goals}")
462        print("-" * 30)
463
464        for i in range(max_iterations):
465            print(f"\n=== Iteration {i + 1} ===")
466
467            # 계획
468            plan = self.plan()
469            print(f"Plan: {plan}")
470
471            if plan.get("task") == "COMPLETE":
472                print(f"완료: {plan['summary']}")
473                return plan["summary"]
474
475            # 실행
476            result = self.execute(plan)
477            print(f"Result: {result}")
478
479            # 메모리 및 완료 목록 업데이트
480            self.memory.append({"plan": plan, "result": result})
481            if result["status"] == "success":
482                self.completed_tasks.append(plan["task"])
483
484        return "최대 반복 횟수 도달"
485
486
487# 테스트
488auto_agent = AutoGPTLikeAgent(
489    tools=tools,
490    goals=["서울 날씨 확인", "간단한 계산"]
491)
492auto_agent.run()
493
494
495# ============================================
496# 정리
497# ============================================
498print("\n" + "=" * 60)
499print("LLM 에이전트 정리")
500print("=" * 60)
501
502summary = """
503LLM 에이전트 핵심 개념:
504
5051. ReAct 패턴:
506   Thought -> Action -> Observation -> ... -> Final Answer
507
5082. 도구 정의:
509   - 이름: 고유 식별자
510   - 설명: LLM이 사용 시점 판단용
511   - 함수: 실제 실행 로직
512
5133. Function Calling (OpenAI):
514   - tools 파라미터로 함수 정의
515   - tool_choice="auto"로 자동 선택
516   - 결과를 role="tool"로 전달
517
5184. 멀티 에이전트:
519   - 역할 분담 (연구, 작성, 검토)
520   - 파이프라인 연결
521   - 협업 프로토콜
522
5235. 자율 에이전트:
524   - 목표 기반 계획
525   - 메모리 유지
526   - 반복적 실행
527
528에이전트 설계 체크리스트:
529□ 명확한 도구 설명
530□ 에러 처리
531□ 무한 루프 방지 (max_steps)
532□ 안전 장치 (위험한 작업 제한)
533□ 로깅 및 디버깅
534"""
535print(summary)