1
[생성된 코드]
2
    │
3
    ├──▶ [Unit Test 실행] ──▶ "2/5 테스트 실패"
4
    │
5
    ├──▶ [Linter 실행] ──▶ "unused variable on line 3"
6
    │
7
    └──▶ [Type Checker] ──▶ "type mismatch on line 7"
8

9
         │
10
         ▼
11
    [구체적인 오류 정보로 수정]

1
rubric = """
2
다음 기준으로 1-5점 평가하세요:
3

4
1. 정확성 (Accuracy): 사실적 오류 없음
5
2. 완성도 (Completeness): 모든 요구사항 충족
6
3. 코드 품질 (Quality): 가독성, 효율성
7
4. 문서화 (Documentation): 주석과 설명 적절함
8

9
각 항목이 4점 이상이면 통과, 아니면 개선 필요.
10
"""

1
MAX_ITERATIONS = 5
2

3
def should_continue(state):
4
    if state["iteration"] >= MAX_ITERATIONS:
5
        return "end"
6
    # ...

1
def should_continue(state):
2
    # 이전 점수와 비교
3
    if state["score"] <= state.get("prev_score", 0):
4
        state["no_improvement_count"] = state.get("no_improvement_count", 0) + 1
5
        if state["no_improvement_count"] >= 2:
6
            return "end"  # 개선 없음, 종료

1
# simple
2
"description": "데이터 검색"
3

4
# Verbose
5
"description": "이 도구는 데이터베이스에서 정보를 검색하는 기능을
6
제공하며, SQL을 사용하여 다양한 테이블에서 데이터를 가져올 수
7
있습니다. 사용자가 고객 정보, 주문 내역, 제품 정보 등을..."
8

9
# 적절함
10
"description": """
11
고객 데이터베이스를 검색합니다.
12
사용 시점: 고객 이름, 이메일, 주문 내역 조회 시
13
입력: 고객 이름 또는 이메일
14
반환: 고객 정보 및 최근 주문 5건
15
"""

1
# 위험한 도구는 확인 절차 추가
2
@tool
3
def delete_file(filepath: str) -> str:
4
    """파일을 삭제합니다. (주의: 복구 불가)"""
5

6
    # Human-in-the-Loop: 사용자 확인 요청
7
    confirmation = request_user_confirmation(
8
        f"정말로 {filepath}를 삭제하시겠습니까?"
9
    )
10

11
    if confirmation:
12
        os.remove(filepath)
13
        return f"{filepath} 삭제 완료"
14
    return "삭제가 취소됨."

1
                    ┌─────────────┐
2
                    │  Manager    │
3
                    │   Agent     │
4
                    └──────┬──────┘
5
                           │
6
            ┌──────────────┼──────────────┐
7
            ▼              ▼              ▼
8
      ┌───────────┐  ┌───────────┐  ┌───────────┐
9
      │  Worker   │  │  Worker   │  │  Worker   │
10
      │  Agent 1  │  │  Agent 2  │  │  Agent 3  │
11
      └───────────┘  └───────────┘  └───────────┘

1
      ┌───────────┐       ┌───────────┐
2
      │  Agent A  │◄─────►│  Agent B  │
3
      └─────┬─────┘       └─────┬─────┘
4
            │                   │
5
            │   ┌───────────┐   │
6
            └──►│  Agent C  │◄──┘
7
                └───────────┘

1
┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐
2
│ Agent 1 │───►│ Agent 2 │───►│ Agent 3 │───►│ Agent 4 │
3
│ Research│    │  Draft  │    │  Edit   │    │ Publish │
4
└─────────┘    └─────────┘    └─────────┘    └─────────┘

1
                    ┌─────────────┐
2
                    │  Manager    │
3
                    └──────┬──────┘
4
                           │
5
            ┌──────────────┼──────────────┐
6
            ▼              ▼              ▼
7
      ┌───────────┐  ┌───────────┐  ┌───────────┐
8
      │ Research  │  │ Research  │  │  Review   │
9
      │ Agent 1   │  │ Agent 2   │  │  Agent    │
10
      └─────┬─────┘  └─────┬─────┘  └───────────┘
11
            │              │              ▲
12
            └──────┬───────┘              │
13
                   ▼                      │
14
             ┌───────────┐                │
15
             │  Writer   │────────────────┘
16
             │  Agent    │
17
             └───────────┘

1
MAX_MESSAGES = 10
2

3
def add_message(messages, new_message):
4
    messages.append(new_message)
5
    if len(messages) > MAX_MESSAGES:
6
        messages = messages[-MAX_MESSAGES:]  # 최근 10개만 유지
7
    return messages

1
MAX_TOKENS = 4000
2

3
def truncate_by_tokens(messages, max_tokens):
4
    total_tokens = 0
5
    result = []
6

7
    # 최신 메시지부터 역순으로
8
    for msg in reversed(messages):
9
        msg_tokens = count_tokens(msg["content"])
10
        if total_tokens + msg_tokens > max_tokens:
11
            break
12
        result.insert(0, msg)
13
        total_tokens += msg_tokens
14

15
    return result

1
def summarize_and_truncate(messages, summary_threshold=20):
2
    if len(messages) <= summary_threshold:
3
        return messages
4

5
    # 오래된 메시지들 요약
6
    old_messages = messages[:-10]
7
    recent_messages = messages[-10:]
8

9
    summary = llm.invoke(f"다음 대화를 핵심만 요약하세요:\n{old_messages}")
10

11
    return [
12
        {"role": "system", "content": f"이전 대화 요약: {summary}"},
13
        *recent_messages
14
    ]

1
┌─────────────────────────────────────────────────────────────────┐
2
│                                                                 │
3
│    [사용자 입력]                                                 │
4
│         │                                                       │
5
│         ▼                                                       │
6
│    ┌─────────────────────────────────────────┐                  │
7
│    │           Memory Manager                │                  │
8
│    │                                         │                  │
9
│    │  1. 관련 기억 검색 (Retrieval)           │                  │
10
│    │  2. 컨텍스트에 추가                      │                  │
11
│    │  3. LLM 호출                            │                  │
12
│    │  4. 새 정보 저장                         │                  │
13
│    └─────────────────────────────────────────┘                  │
14
│         │                   │                                   │
15
│         ▼                   ▼                                   │
16
│    ┌─────────┐        ┌─────────────┐                          │
17
│    │Short-term│       │  Long-term  │                          │
18
│    │ Memory  │        │   Memory    │                          │
19
│    │         │        │             │                          │
20
│    │ 현재    │        │ • DB        │                          │
21
│    │ 대화    │        │ • Vector    │                          │
22
│    │         │        │   Store     │                          │
23
│    └─────────┘        └─────────────┘                          │
24
│                                                                 │
25
└─────────────────────────────────────────────────────────────────┘

1
pythonfrom langchain_community.vectorstores import FAISS
2
from langchain_openai import OpenAIEmbeddings
3

4
class ExperienceMemory:
5
    def __init__(self):
6
        self.embeddings = OpenAIEmbeddings()
7
        self.experience_store = None
8
        self.experiences = []
9

10
    def store_experience(self, task, action, outcome, success: bool):
11
        experience = {
12
            "task": task,
13
            "action": action,
14
            "outcome": outcome,
15
            "success": success
16
        }
17
        self.experiences.append(experience)
18

19
        # 벡터 스토어 업데이트
20
        text = f"Task: {task}\nAction: {action}\nSuccess: {success}"
21
        if self.experience_store is None:
22
            self.experience_store = FAISS.from_texts([text], self.embeddings)
23
        else:
24
            self.experience_store.add_texts([text])
25

26
    def retrieve_relevant_experiences(self, current_task, k=3):
27
        if self.experience_store is None:
28
            return []
29

30
        # 유사한 과거 경험 검색
31
        results = self.experience_store.similarity_search(current_task, k=k)
32
        return results
33

34
    def get_guidance(self, current_task):
35
        experiences = self.retrieve_relevant_experiences(current_task)
36

37
        successes = [e for e in experiences if "Success: True" in e.page_content]
38
        failures = [e for e in experiences if "Success: False" in e.page_content]
39

40
        guidance = ""
41
        if successes:
42
            guidance += f"과거 성공 사례 참고:\n{successes[0].page_content}\n"
43
        if failures:
44
            guidance += f"과거 실패 사례 (피하세요):\n{failures[0].page_content}\n"
45

46
        return guidance