# Agentic RAG

이 강의는 Agentic Retrieval-Augmented Generation (Agentic RAG)에 대한 포괄적인 개요를 제공합니다. 이는 대규모 언어 모델(LLM)이 외부 소스로부터 정보를 가져오면서 다음 단계를 자율적으로 계획하는 AI의 새로운 패러다임입니다. 정적 검색 후 읽기 패턴과 달리, Agentic RAG는 도구나 함수 호출 및 구조화된 출력을 포함한 반복적인 LLM 호출을 특징으로 합니다. 시스템은 결과를 평가하고, 쿼리를 개선하며, 필요시 추가 도구를 호출하고, 만족스러운 솔루션이 나올 때까지 이 과정을 반복합니다.

## 소개

이 강의에서는 다음 내용을 다룹니다:

- **Agentic RAG 이해하기:** 대규모 언어 모델(LLM)이 외부 데이터 소스에서 정보를 가져오면서 다음 단계를 자율적으로 계획하는 AI의 새로운 패러다임에 대해 학습합니다.
- **반복적 Maker-Checker 스타일 익히기:** LLM 호출과 도구 또는 함수 호출 및 구조화된 출력이 반복되는 루프를 이해하며, 이는 정확성을 개선하고 잘못된 쿼리를 처리하도록 설계되었습니다.
- **실용적 응용 탐구:** 정확성 우선 환경, 복잡한 데이터베이스 상호작용, 확장된 워크플로우와 같은 상황에서 Agentic RAG가 빛을 발하는 사례를 확인합니다.

## 학습 목표

이 강의를 완료하면 다음을 알게 됩니다:

- **Agentic RAG 이해:** 대규모 언어 모델(LLM)이 외부 데이터 소스에서 정보를 가져오면서 다음 단계를 자율적으로 계획하는 AI의 새로운 패러다임에 대해 학습합니다.
- **반복적 Maker-Checker 스타일:** LLM 호출과 도구 또는 함수 호출 및 구조화된 출력이 반복되는 루프의 개념을 이해하며, 이는 정확성을 개선하고 잘못된 쿼리를 처리하도록 설계되었습니다.
- **추론 과정 소유하기:** 시스템이 사전 정의된 경로에 의존하지 않고 문제를 해결하는 방법을 결정하는 능력을 이해합니다.
- **워크플로우:** 에이전트 모델이 독립적으로 시장 동향 보고서를 검색하고, 경쟁사 데이터를 식별하며, 내부 판매 지표를 상관시키고, 결과를 종합하고, 전략을 평가하는 과정을 이해합니다.
- **반복적 루프, 도구 통합 및 메모리:** 시스템이 반복적 상호작용 패턴에 의존하며, 상태와 메모리를 유지하여 반복 루프를 피하고 정보에 입각한 결정을 내리는 방법을 학습합니다.
- **실패 모드 처리 및 자기 수정:** 진단 도구를 사용하거나 인간 감독에 의존하는 등 시스템의 강력한 자기 수정 메커니즘을 탐구합니다.
- **에이전시의 한계:** 도메인별 자율성, 인프라 의존성, 안전 장치 준수를 중심으로 Agentic RAG의 한계를 이해합니다.
- **실용적 사용 사례 및 가치:** 정확성 우선 환경, 복잡한 데이터베이스 상호작용, 확장된 워크플로우와 같은 상황에서 Agentic RAG가 빛을 발하는 사례를 확인합니다.
- **거버넌스, 투명성, 신뢰:** 설명 가능한 추론, 편향 제어, 인간 감독 등 거버넌스와 투명성의 중요성을 학습합니다.

## Agentic RAG란 무엇인가?

Agentic Retrieval-Augmented Generation (Agentic RAG)은 대규모 언어 모델(LLM)이 외부 소스로부터 정보를 가져오면서 다음 단계를 자율적으로 계획하는 AI의 새로운 패러다임입니다. 정적 검색 후 읽기 패턴과 달리, Agentic RAG는 도구나 함수 호출 및 구조화된 출력을 포함한 반복적인 LLM 호출을 특징으로 합니다. 시스템은 결과를 평가하고, 쿼리를 개선하며, 필요시 추가 도구를 호출하고, 만족스러운 솔루션이 나올 때까지 이 과정을 반복합니다. 이러한 반복적인 "maker-checker" 스타일은 정확성을 개선하고, 잘못된 쿼리를 처리하며, 높은 품질의 결과를 보장합니다.

시스템은 추론 과정을 적극적으로 소유하며, 실패한 쿼리를 다시 작성하거나, 다른 검색 방법을 선택하고, 여러 도구(예: Azure AI Search의 벡터 검색, SQL 데이터베이스, 사용자 지정 API)를 통합하여 최종 답변을 도출합니다. 에이전틱 시스템의 차별화된 품질은 추론 과정을 스스로 소유하는 능력입니다. 기존 RAG 구현은 사전 정의된 경로에 의존하지만, 에이전틱 시스템은 발견된 정보의 품질에 따라 단계의 순서를 자율적으로 결정합니다.

## Agentic Retrieval-Augmented Generation (Agentic RAG) 정의

Agentic Retrieval-Augmented Generation (Agentic RAG)은 LLM이 외부 데이터 소스에서 정보를 가져오는 것뿐만 아니라, 다음 단계를 자율적으로 계획하는 AI 개발의 새로운 패러다임입니다. 정적 검색 후 읽기 패턴이나 신중히 스크립트된 프롬프트 시퀀스와 달리, Agentic RAG는 도구나 함수 호출 및 구조화된 출력을 포함한 반복적인 LLM 호출 루프를 특징으로 합니다. 매 단계마다 시스템은 얻은 결과를 평가하고, 쿼리를 개선하거나, 필요시 추가 도구를 호출하며, 만족스러운 솔루션이 나올 때까지 이 과정을 반복합니다.

이 반복적인 "maker-checker" 운영 스타일은 정확성을 개선하고, 구조화된 데이터베이스(NL2SQL 등)에 대한 잘못된 쿼리를 처리하며, 균형 잡힌 고품질 결과를 보장하도록 설계되었습니다. 신중히 설계된 프롬프트 체인에만 의존하는 대신, 시스템은 추론 과정을 적극적으로 소유합니다. 실패한 쿼리를 다시 작성하거나, 다른 검색 방법을 선택하고, 여러 도구(예: Azure AI Search의 벡터 검색, SQL 데이터베이스, 사용자 지정 API)를 통합하여 최종 답변을 도출합니다. 이는 지나치게 복잡한 오케스트레이션 프레임워크의 필요성을 제거합니다. 대신, "LLM 호출 → 도구 사용 → LLM 호출 → ..."라는 비교적 간단한 루프를 통해 정교하고 근거 있는 출력을 도출할 수 있습니다.

![Agentic RAG Core Loop](../../../translated_images/agentic-rag-core-loop.2224925a913fb3439f518bda61a40096ddf6aa432a11c9b5bba8d0d625e47b79.ko.png)

## 추론 과정 소유하기

시스템을 "에이전틱"하게 만드는 가장 큰 특징은 추론 과정을 스스로 소유하는 능력입니다. 기존 RAG 구현은 모델이 어떤 정보를 검색하고 언제 검색해야 할지에 대한 체인을 인간이 사전에 정의하는 경우가 많습니다. 그러나 진정으로 에이전틱한 시스템은 문제를 해결하는 방법을 내부적으로 결정합니다. 단순히 스크립트를 실행하는 것이 아니라, 발견된 정보의 품질에 따라 단계의 순서를 자율적으로 결정합니다.

예를 들어, 제품 출시 전략을 수립하라는 요청을 받았을 때, 에이전틱 모델은 전체 연구 및 의사 결정 워크플로우를 명시하는 프롬프트에만 의존하지 않습니다. 대신, 모델은 독립적으로 다음 단계를 결정합니다:

1. Bing Web Grounding을 사용하여 현재 시장 동향 보고서를 검색합니다.
2. Azure AI Search를 사용하여 관련 경쟁사 데이터를 식별합니다.
3. Azure SQL Database를 사용하여 과거 내부 판매 지표를 상관 분석합니다.
4. Azure OpenAI Service를 통해 결과를 종합하여 일관된 전략을 작성합니다.
5. 전략의 격차나 불일치를 평가하며, 필요한 경우 추가 검색을 진행합니다.

이 모든 단계—쿼리 개선, 소스 선택, "만족"할 때까지 반복—는 사람이 미리 스크립트화한 것이 아니라 모델이 스스로 결정합니다.

## 반복적 루프, 도구 통합 및 메모리

![Tool Integration Architecture](../../../translated_images/tool-integration.7b05a923e3278bf1fd2972faa228fb2ac725f166ed084362b031a24bffd26287.ko.png)

에이전틱 시스템은 반복적 상호작용 패턴에 의존합니다:

- **초기 호출:** 사용자의 목표(사용자 프롬프트)가 LLM에 제시됩니다.
- **도구 호출:** 모델이 누락된 정보나 모호한 지침을 식별하면, 벡터 데이터베이스 쿼리(예: Azure AI Search Hybrid search over private data)나 구조화된 SQL 호출과 같은 도구나 검색 방법을 선택하여 더 많은 컨텍스트를 수집합니다.
- **평가 및 개선:** 반환된 데이터를 검토한 후, 모델은 정보가 충분한지 여부를 결정합니다. 그렇지 않다면, 쿼리를 개선하거나, 다른 도구를 시도하거나, 접근 방식을 조정합니다.
- **만족할 때까지 반복:** 이 주기는 모델이 충분한 명확성과 증거를 확보하여 최종적이고 논리적인 응답을 제공할 때까지 계속됩니다.
- **메모리 및 상태:** 시스템은 단계별로 상태와 메모리를 유지하기 때문에 이전 시도와 결과를 기억하고, 반복 루프를 피하며 더 나은 결정을 내릴 수 있습니다.

시간이 지남에 따라 이는 점진적인 이해를 형성하며, 모델이 복잡하고 다단계 작업을 인간의 지속적인 개입이나 프롬프트 재구성 없이도 처리할 수 있도록 합니다.

## 실패 모드 처리 및 자기 수정

Agentic RAG의 자율성은 강력한 자기 수정 메커니즘도 포함합니다. 시스템이 막다른 길에 도달했을 때—예를 들어, 관련 없는 문서를 검색하거나 잘못된 쿼리를 마주칠 경우—다음과 같은 조치를 취할 수 있습니다:

- **반복 및 재쿼리:** 가치가 낮은 응답을 반환하는 대신, 모델은 새로운 검색 전략을 시도하거나, 데이터베이스 쿼리를 다시 작성하거나, 대체 데이터 세트를 탐색합니다.
- **진단 도구 사용:** 시스템은 추론 단계를 디버그하거나 검색된 데이터의 정확성을 확인하기 위해 추가 기능을 호출할 수 있습니다. Azure AI Tracing과 같은 도구는 강력한 관찰 가능성과 모니터링을 가능하게 합니다.
- **인간 감독 의존:** 높은 위험이 있거나 반복적으로 실패하는 시나리오에서는 모델이 불확실성을 표시하고 인간의 지침을 요청할 수 있습니다. 인간이 교정 피드백을 제공하면, 모델은 이를 향후에 반영할 수 있습니다.

이 반복적이고 동적인 접근 방식은 모델이 지속적으로 개선되도록 하며, 단순히 한 번 실행되는 시스템이 아니라 세션 중에 실수를 학습하는 시스템이 되도록 보장합니다.

![Self Correction Mechanism](../../../translated_images/self-correction.3d42c31baf4a476bb89313cec58efb196b0e97959c04d7439cc23d27ef1242ac.ko.png)

## 에이전시의 한계

Agentic RAG는 작업 내에서 자율성을 가지지만, 이를 인공지능 일반 지능(AGI)과 동일시할 수는 없습니다. "에이전틱" 기능은 인간 개발자가 제공한 도구, 데이터 소스, 정책 내에서만 작동합니다. 자체 도구를 발명하거나 설정된 도메인 경계를 벗어날 수 없습니다. 대신, 제공된 자원을 동적으로 조정하는 데 탁월합니다.

주요 차이점은 다음과 같습니다:

1. **도메인별 자율성:** Agentic RAG 시스템은 알려진 도메인 내에서 사용자 정의 목표를 달성하는 데 중점을 두며, 쿼리 재작성이나 도구 선택과 같은 전략을 사용하여 결과를 개선합니다.
2. **인프라 의존성:** 시스템의 기능은 개발자가 통합한 도구와 데이터에 따라 달라집니다. 인간의 개입 없이는 이러한 경계를 초월할 수 없습니다.
3. **안전 장치 준수:** 윤리적 지침, 규정 준수 규칙, 비즈니스 정책은 여전히 매우 중요합니다. 에이전트의 자유는 항상 안전 조치와 감독 메커니즘에 의해 제한됩니다(희망적으로?).

## 실용적 사용 사례 및 가치

Agentic RAG는 반복적인 정제와 정확성이 요구되는 시나리오에서 빛을 발합니다:

1. **정확성 우선 환경:** 규정 준수 검사, 규제 분석, 법률 연구와 같은 경우, 에이전틱 모델은 사실을 반복적으로 확인하고, 여러 소스를 참조하며, 쿼리를 다시 작성하여 철저히 검증된 답변을 제공합니다.
2. **복잡한 데이터베이스 상호작용:** 구조화된 데이터와 작업할 때 쿼리가 자주 실패하거나 조정이 필요한 경우, 시스템은 Azure SQL이나 Microsoft Fabric OneLake를 사용하여 쿼리를 자율적으로 정제하여 최종 검색 결과가 사용자의 의도와 일치하도록 보장합니다.
3. **확장된 워크플로우:** 새로운 정보가 표면화됨에 따라 세션이 진화할 수 있습니다. Agentic RAG는 문제 공간에 대해 더 많이 배우면서 지속적으로 새 데이터를 통합하고 전략을 변경할 수 있습니다.

## 거버넌스, 투명성, 신뢰

이러한 시스템이 추론에서 더 자율적으로 발전함에 따라, 거버넌스와 투명성이 중요합니다:

- **설명 가능한 추론:** 모델은 수행한 쿼리, 참조한 소스, 결론에 도달하기 위해 취한 추론 단계를 감사 추적 형태로 제공할 수 있습니다. Azure AI Content Safety와 Azure AI Tracing / GenAIOps와 같은 도구는 투명성을 유지하고 위험을 완화하는 데 도움이 됩니다.
- **편향 제어 및 균형 잡힌 검색:** 개발자는 검색 전략을 조정하여 균형 잡힌 대표 데이터를 고려하도록 하고, Azure Machine Learning을 사용하는 고급 데이터 과학 조직의 사용자 지정 모델을 통해 출력물을 정기적으로 감사하여 편향이나 왜곡된 패턴을 감지할 수 있습니다.
- **인간 감독 및 규정 준수:** 민감한 작업의 경우, 인간 검토는 여전히 필수적입니다. Agentic RAG는 고위험 결정에서 인간의 판단을 대체하는 것이 아니라, 더 철저히 검토된 옵션을 제공하여 이를 보완합니다.

다단계 프로세스를 디버깅하기 위해 명확한 작업 기록을 제공하는 도구가 필수적입니다. 그렇지 않으면 디버깅이 매우 어려울 수 있습니다. 아래는 Literal AI(Chainlit 개발 회사)의 에이전트 실행 예제입니다:

![AgentRunExample](../../../translated_images/AgentRunExample.27e2df23ad898772d1b3e7a3e3cd4615378e10dfda87ae8f06b4748bf8eea97d.ko.png)

![AgentRunExample2](../../../translated_images/AgentRunExample2.c0e8c78b1f2540a641515e60035abcc6a9c5e3688bae143eb6c559dd37cdee9f.ko.png)

## 결론

Agentic RAG는 AI 시스템이 복잡하고 데이터 집약적인 작업을 처리하는 방식에서 자연스러운 진화를 나타냅니다. 반복적인 상호작용 패턴을 채택하고, 도구를 자율적으로 선택하며, 고품질 결과를 달성할 때까지 쿼리를 정제함으로써, 이 시스템은 정적 프롬프트 추종을 넘어 보다 적응적이고 맥락을 인식하는 의사 결정자로 발전합니다. 여전히 인간이 정의한 인프라와 윤리적 지침에 의해 제한되지만, 이러한 에이전틱 기능은 기업과 최종 사용자 모두에게 더 풍부하고 동적이며 궁극적으로 더 유용한 AI 상호작용을 가능하게 합니다.

## 추가 리소스

- Implement Retrieval Augmented Generation (RAG) with Azure OpenAI Service: Learn how to use your own data with the Azure OpenAI Service.[This Microsoft Learn module provides a comprehensive guide on implementing RAG](https://learn.microsoft.com/training/modules/use-own-data-azure-openai)
- Evaluation of generative AI applications with Azure AI Foundry: This article covers the evaluation and comparison of models on publicly available datasets, including [Agentic AI applications and RAG architectures](https://learn.microsoft.com/azure/ai-studio/concepts/evaluation-approach-gen-ai)
- [What is Agentic RAG | Weaviate](https://weaviate.io/blog/what-is-agentic-rag)
- [Agentic RAG: A Complete Guide to Agent-Based Retrieval Augmented Generation – News from generation RAG](https://ragaboutit.com/agentic-rag-a-complete-guide-to-agent-based-retrieval-augmented-generation/)
- [Agentic RAG: turbocharge your RAG with query reformulation and self-query! Hugging Face Open-Source AI Cookbook](https://huggingface.co/learn/cookbook/agent_rag)
- [Adding Agentic Layers to RAG](https://youtu.be/aQ4yQXeB1Ss?si=2HUqBzHoeB5tR04U)
- [The Future of Knowledge Assistants: Jerry Liu](https://www.youtube.com/watch?v=zeAyuLc_f3Q&t=244s)
- [How to Build Agentic RAG Systems](https://www.youtube.com/watch?v=AOSjiXP1jmQ)
- [Using Azure AI Foundry Agent Service to scale your AI agents](https://ignite.microsoft.com/sessions/BRK102?source=sessions)

### 학술 논문

- [2303.17651 Self-Refine: Iterative Refinement with Self-Feedback](https://arxiv.org/abs/2303.17651)
- [2303.11366 Reflexion: Language Agents with Verbal Reinforcement Learning](https://arxiv.org/abs/2303.11366)
- [2305.11738 CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing](https://arxiv.org/abs/2305.11738)
```

**면책 조항**:
이 문서는 AI 기반 기계 번역 서비스를 사용하여 번역되었습니다. 정확성을 위해 노력하고 있지만, 자동 번역에는 오류나 부정확성이 포함될 수 있습니다. 원본 문서(모국어로 작성된 문서)가 권위 있는 자료로 간주되어야 합니다. 중요한 정보의 경우, 전문적인 인간 번역을 권장합니다. 이 번역을 사용함으로 인해 발생하는 오해나 잘못된 해석에 대해 당사는 책임을 지지 않습니다.


# 신뢰할 수 있는 AI 에이전트 구축

## 소개

이 강의에서는 다음 내용을 다룹니다:

- 안전하고 효과적인 AI 에이전트를 구축하고 배포하는 방법
- AI 에이전트를 개발할 때 고려해야 할 중요한 보안 사항
- AI 에이전트를 개발할 때 데이터와 사용자 프라이버시를 유지하는 방법

## 학습 목표

이 강의를 완료한 후, 여러분은 다음을 할 수 있습니다:

- AI 에이전트를 생성할 때 발생할 수 있는 위험을 식별하고 완화하는 방법을 이해합니다.
- 데이터와 접근 권한을 적절히 관리하기 위한 보안 조치를 구현합니다.
- 데이터 프라이버시를 유지하고 품질 높은 사용자 경험을 제공하는 AI 에이전트를 만듭니다.

## 안전성

우선 안전한 에이전트 기반 애플리케이션을 구축하는 방법을 살펴보겠습니다. 안전성이란 AI 에이전트가 설계된 대로 작동하는 것을 의미합니다. 에이전트 기반 애플리케이션을 구축하는 개발자로서, 우리는 안전성을 극대화하기 위한 방법과 도구를 가지고 있습니다.

### 메타 프롬프팅 시스템 구축

대규모 언어 모델(LLMs)을 사용해 AI 애플리케이션을 만들어본 경험이 있다면, 견고한 시스템 프롬프트나 시스템 메시지를 설계하는 것이 얼마나 중요한지 알 것입니다. 이러한 프롬프트는 LLM이 사용자 및 데이터와 상호작용하는 방식에 대한 메타 규칙, 지침, 가이드를 설정합니다.

AI 에이전트의 경우, 시스템 프롬프트는 더욱 중요합니다. AI 에이전트가 설계된 작업을 수행하려면 매우 구체적인 지침이 필요하기 때문입니다.

확장 가능한 시스템 프롬프트를 생성하려면, 애플리케이션에서 하나 이상의 에이전트를 구축하기 위한 메타 프롬프팅 시스템을 사용할 수 있습니다:

![메타 프롬프팅 시스템 구축](../../../translated_images/building-a-metaprompting-system.aa7d6de2100b0ef48c3e1926dab6903026b22fc9d27fc4327162fbbb9caf960f.ko.png)

#### 1단계: 메타 또는 템플릿 프롬프트 생성

메타 프롬프트는 우리가 생성하는 에이전트의 시스템 프롬프트를 생성하기 위해 LLM이 사용할 템플릿입니다. 필요에 따라 여러 에이전트를 효율적으로 생성할 수 있도록 템플릿 형태로 설계합니다.

다음은 LLM에 제공할 메타 프롬프트의 예입니다:

```plaintext
You are an expert at creating AI agent assitants.
You will be provided a company name, role, responsibilites and other
information that you will use to provide a system prompt for.
To create the system prompt, be descriptive as possible and provide a structure that a system using an LLM can better understand the role and responsibilites of the AI assistant.
```

#### 2단계: 기본 프롬프트 생성

다음 단계는 AI 에이전트를 설명하는 기본 프롬프트를 작성하는 것입니다. 여기에는 에이전트의 역할, 에이전트가 수행할 작업, 기타 책임이 포함되어야 합니다.

다음은 그 예입니다:

```plaintext
You are a travel agent for Contoso Travel with that is great at booking flights for customers. To help customers you can perform the following tasks: lookup available flights, book flights, ask for preferences in seating and times for flights, cancel any previously booked flights and alert customers on any delays or cancellations of flights.
```

#### 3단계: LLM에 기본 프롬프트 제공

이제 메타 프롬프트를 시스템 프롬프트로 제공하고 기본 프롬프트를 추가하여 최적화된 프롬프트를 생성할 수 있습니다.

이렇게 하면 AI 에이전트를 보다 효과적으로 안내할 수 있는 프롬프트가 생성됩니다:

```markdown
**Company Name:** Contoso Travel
**Role:** Travel Agent Assistant

**Objective:**
You are an AI-powered travel agent assistant for Contoso Travel, specializing in booking flights and providing exceptional customer service. Your main goal is to assist customers in finding, booking, and managing their flights, all while ensuring that their preferences and needs are met efficiently.

**Key Responsibilities:**

1. **Flight Lookup:**

    - Assist customers in searching for available flights based on their specified destination, dates, and any other relevant preferences.
    - Provide a list of options, including flight times, airlines, layovers, and pricing.
2. **Flight Booking:**

    - Facilitate the booking of flights for customers, ensuring that all details are correctly entered into the system.
    - Confirm bookings and provide customers with their itinerary, including confirmation numbers and any other pertinent information.
3. **Customer Preference Inquiry:**

    - Actively ask customers for their preferences regarding seating (e.g., aisle, window, extra legroom) and preferred times for flights (e.g., morning, afternoon, evening).
    - Record these preferences for future reference and tailor suggestions accordingly.
4. **Flight Cancellation:**

    - Assist customers in canceling previously booked flights if needed, following company policies and procedures.
    - Notify customers of any necessary refunds or additional steps that may be required for cancellations.
5. **Flight Monitoring:**

    - Monitor the status of booked flights and alert customers in real-time about any delays, cancellations, or changes to their flight schedule.
    - Provide updates through preferred communication channels (e.g., email, SMS) as needed.

**Tone and Style:**

- Maintain a friendly, professional, and approachable demeanor in all interactions with customers.
- Ensure that all communication is clear, informative, and tailored to the customer's specific needs and inquiries.

**User Interaction Instructions:**

- Respond to customer queries promptly and accurately.
- Use a conversational style while ensuring professionalism.
- Prioritize customer satisfaction by being attentive, empathetic, and proactive in all assistance provided.

**Additional Notes:**

- Stay updated on any changes to airline policies, travel restrictions, and other relevant information that could impact flight bookings and customer experience.
- Use clear and concise language to explain options and processes, avoiding jargon where possible for better customer understanding.

This AI assistant is designed to streamline the flight booking process for customers of Contoso Travel, ensuring that all their travel needs are met efficiently and effectively.

```

#### 4단계: 반복 및 개선

메타 프롬프팅 시스템의 가치는 여러 에이전트를 쉽게 생성할 수 있을 뿐만 아니라, 프롬프트를 지속적으로 개선할 수 있다는 점입니다. 처음부터 완벽하게 작동하는 프롬프트를 얻는 것은 드문 일이므로, 기본 프롬프트를 약간씩 수정하고 시스템을 통해 실행해 결과를 비교하고 평가하는 것이 중요합니다.

## 위협 이해하기

신뢰할 수 있는 AI 에이전트를 구축하려면, AI 에이전트에 대한 위험과 위협을 이해하고 이를 완화하는 것이 중요합니다. 이제 AI 에이전트에 대한 다양한 위협과 이를 대비하고 계획하는 방법에 대해 살펴보겠습니다.

![위협 이해하기](../../../translated_images/understanding-threats.f8fbe6fe11e025b3085fc91e82d975937ad1d672260a2aeed40458aa41798d0e.ko.png)

### 작업 및 지침

**설명:** 공격자는 프롬프트나 입력값을 조작하여 AI 에이전트의 지침이나 목표를 변경하려고 시도합니다.

**완화 방안:** AI 에이전트가 입력을 처리하기 전에 잠재적으로 위험한 프롬프트를 탐지할 수 있도록 검증 및 입력 필터링을 실행하세요. 이러한 공격은 일반적으로 에이전트와의 빈번한 상호작용을 필요로 하므로, 대화 횟수를 제한하는 것도 이러한 공격을 방지하는 방법입니다.

### 중요한 시스템에 대한 접근

**설명:** AI 에이전트가 민감한 데이터를 저장하는 시스템 및 서비스에 접근할 수 있는 경우, 공격자는 에이전트와 이러한 서비스 간의 통신을 손상시킬 수 있습니다. 이는 직접적인 공격이거나 에이전트를 통해 시스템 정보를 얻으려는 간접적인 시도일 수 있습니다.

**완화 방안:** AI 에이전트는 필요할 때만 시스템에 접근할 수 있도록 제한해야 합니다. 에이전트와 시스템 간의 통신은 반드시 안전해야 하며, 인증 및 접근 제어를 구현하여 정보를 보호하세요.

### 리소스 및 서비스 과부하

**설명:** AI 에이전트는 작업을 완료하기 위해 다양한 도구와 서비스를 사용할 수 있습니다. 공격자는 AI 에이전트를 통해 대량의 요청을 전송하여 해당 서비스에 시스템 장애나 높은 비용을 초래할 수 있습니다.

**완화 방안:** AI 에이전트가 서비스에 보낼 수 있는 요청 수를 제한하는 정책을 구현하세요. 대화 횟수와 요청 수를 제한하는 것도 이러한 공격을 방지하는 방법입니다.

### 지식 베이스 오염

**설명:** 이 유형의 공격은 AI 에이전트를 직접적으로 공격하는 것이 아니라, 에이전트가 사용하는 지식 베이스나 기타 서비스를 대상으로 합니다. 이는 데이터를 손상시키거나 AI 에이전트가 작업을 수행하는 데 사용하는 정보를 왜곡하여 편향되거나 의도하지 않은 응답을 유도할 수 있습니다.

**완화 방안:** AI 에이전트가 워크플로우에서 사용하는 데이터를 정기적으로 검증하세요. 이 데이터에 대한 접근은 반드시 신뢰할 수 있는 사람만 변경할 수 있도록 보안 조치를 취하세요.

### 연쇄 오류

**설명:** AI 에이전트는 작업을 완료하기 위해 다양한 도구와 서비스에 접근합니다. 공격으로 인해 발생한 오류가 AI 에이전트가 연결된 다른 시스템의 장애로 이어질 수 있으며, 이는 공격이 더 광범위하게 확산되고 문제 해결이 어려워질 수 있습니다.

**완화 방안:** AI 에이전트가 Docker 컨테이너와 같은 제한된 환경에서 작업하도록 하여 직접적인 시스템 공격을 방지하세요. 특정 시스템이 오류를 반환할 경우 대체 메커니즘과 재시도 로직을 구현하여 더 큰 시스템 장애를 방지하세요.

## 인간 개입 루프

신뢰할 수 있는 AI 에이전트 시스템을 구축하는 또 다른 효과적인 방법은 인간 개입 루프를 사용하는 것입니다. 이는 사용자가 실행 중인 에이전트에 피드백을 제공할 수 있는 흐름을 만듭니다. 사용자는 다중 에이전트 시스템의 하나의 에이전트처럼 작동하며, 실행 중인 프로세스를 승인하거나 종료하는 역할을 합니다.

![인간 개입 루프](../../../translated_images/human-in-the-loop.e9edbe8f6d42041b4213421410823250aa750fe8bdba5601d69ed46f3ff6489d.ko.png)

다음은 AutoGen을 사용하여 이 개념을 구현하는 코드 스니펫입니다:

```python

# Create the agents.
model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")
assistant = AssistantAgent("assistant", model_client=model_client)
user_proxy = UserProxyAgent("user_proxy", input_func=input)  # Use input() to get user input from console.

# Create the termination condition which will end the conversation when the user says "APPROVE".
termination = TextMentionTermination("APPROVE")

# Create the team.
team = RoundRobinGroupChat([assistant, user_proxy], termination_condition=termination)

# Run the conversation and stream to the console.
stream = team.run_stream(task="Write a 4-line poem about the ocean.")
# Use asyncio.run(...) when running in a script.
await Console(stream)

```
```

**면책 조항**:
이 문서는 기계 기반 AI 번역 서비스를 사용하여 번역되었습니다. 정확성을 위해 최선을 다하고 있지만, 자동 번역에는 오류나 부정확성이 포함될 수 있음을 유의하시기 바랍니다. 원본 문서의 원어 버전이 신뢰할 수 있는 권위 있는 자료로 간주되어야 합니다. 중요한 정보에 대해서는 전문적인 인간 번역을 권장합니다. 이 번역 사용으로 인해 발생하는 오해나 잘못된 해석에 대해 당사는 책임을 지지 않습니다.

10 Lessons to Get Started Building AI Agents


# 설계 계획

## 소개

이 강의에서는 다음 내용을 다룹니다:

* 명확한 전체 목표를 정의하고 복잡한 작업을 관리 가능한 작업으로 나누는 방법.
* 구조화된 출력을 활용하여 더 신뢰할 수 있고 기계가 읽을 수 있는 응답을 생성하는 방법.
* 이벤트 기반 접근 방식을 적용하여 동적 작업과 예기치 않은 입력을 처리하는 방법.

## 학습 목표

이 강의를 완료한 후에는 다음 내용을 이해할 수 있습니다:

* AI 에이전트의 전체 목표를 설정하고, 이를 통해 무엇을 달성해야 하는지 명확히 알 수 있도록 합니다.
* 복잡한 작업을 관리 가능한 하위 작업으로 나누고 이를 논리적인 순서로 조직합니다.
* 에이전트에게 적합한 도구(예: 검색 도구 또는 데이터 분석 도구)를 제공하고, 언제 어떻게 사용할지 결정하며 발생하는 예기치 않은 상황을 처리합니다.
* 하위 작업의 결과를 평가하고 성능을 측정하며, 최종 출력을 개선하기 위해 행동을 반복적으로 수정합니다.

## 전체 목표 정의 및 작업 세분화

![목표와 작업 정의](../../../translated_images/defining-goals-tasks.dcc1181bbdb194704ae0fb3363371562949e8b03fd2fadc256218aaadf84a9f4.ko.png)

대부분의 실제 작업은 한 번에 해결하기에는 너무 복잡합니다. AI 에이전트는 계획 및 행동을 안내할 간결한 목표가 필요합니다. 예를 들어, 다음과 같은 목표를 고려해 봅시다:

    "3일간의 여행 일정 생성하기."

이 목표는 간단히 표현되었지만, 여전히 구체화가 필요합니다. 목표가 명확할수록 에이전트(및 협력하는 사람들)가 올바른 결과를 달성하는 데 더 집중할 수 있습니다. 예를 들어, 항공편 옵션, 호텔 추천, 활동 제안을 포함하는 포괄적인 일정을 만드는 것이 그 예입니다.

### 작업 세분화

큰 작업이나 복잡한 작업은 더 작은 목표 지향적인 하위 작업으로 나누면 더 쉽게 관리할 수 있습니다.
여행 일정 예제를 기준으로 하면, 목표를 다음과 같이 세분화할 수 있습니다:

* 항공편 예약
* 호텔 예약
* 렌터카 예약
* 개인화

각 하위 작업은 전담 에이전트나 프로세스에 의해 처리될 수 있습니다. 한 에이전트는 최적의 항공편을 검색하는 데 전문화되고, 다른 에이전트는 호텔 예약을 담당하는 식입니다. 이후 조정 또는 "다운스트림" 에이전트가 이러한 결과를 하나의 완성된 일정으로 통합하여 최종 사용자에게 제공합니다.

이 모듈식 접근 방식은 점진적인 개선도 가능하게 합니다. 예를 들어, 음식 추천이나 현지 활동 제안을 전문으로 하는 에이전트를 추가하여 일정의 품질을 점진적으로 개선할 수 있습니다.

### 구조화된 출력

대형 언어 모델(LLM)은 다운스트림 에이전트나 서비스가 더 쉽게 구문 분석하고 처리할 수 있는 구조화된 출력(예: JSON)을 생성할 수 있습니다. 이는 계획 출력이 수신된 후 작업을 실행하는 다중 에이전트 컨텍스트에서 특히 유용합니다. 자세한 내용은 [이 블로그 글](https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/cookbook/structured-output-agent.html)을 참고하세요.

아래는 목표를 하위 작업으로 분해하고 구조화된 계획을 생성하는 간단한 계획 에이전트를 보여주는 Python 코드 예제입니다:

### 다중 에이전트 오케스트레이션을 활용한 계획 에이전트

이 예제에서, 시맨틱 라우터 에이전트는 사용자 요청(예: "여행을 위한 호텔 계획이 필요합니다.")을 받습니다.

플래너는 다음을 수행합니다:

* 호텔 계획 수신: 플래너는 사용자의 메시지를 받고, 시스템 프롬프트(사용 가능한 에이전트 세부 정보 포함)를 기반으로 구조화된 여행 계획을 생성합니다.
* 에이전트와 그 도구 나열: 에이전트 레지스트리는 항공편, 호텔, 렌터카, 활동 등을 위한 에이전트 목록과 그들이 제공하는 기능 또는 도구를 포함합니다.
* 계획을 해당 에이전트에 라우팅: 하위 작업의 수에 따라, 플래너는 메시지를 전용 에이전트(단일 작업 시나리오의 경우)에게 직접 보내거나, 다중 에이전트 협업을 위한 그룹 채팅 관리자를 통해 조정합니다.
* 결과 요약: 마지막으로, 플래너는 생성된 계획을 명확히 요약합니다.

아래는 이러한 단계를 보여주는 Python 코드 샘플입니다:

```python

from pydantic import BaseModel

from enum import Enum
from typing import List, Optional, Union

class AgentEnum(str, Enum):
    FlightBooking = "flight_booking"
    HotelBooking = "hotel_booking"
    CarRental = "car_rental"
    ActivitiesBooking = "activities_booking"
    DestinationInfo = "destination_info"
    DefaultAgent = "default_agent"
    GroupChatManager = "group_chat_manager"

# Travel SubTask Model

class TravelSubTask(BaseModel):
    task_details: str
    assigned_agent: AgentEnum # we want to assign the task to the agent

class TravelPlan(BaseModel):
    main_task: str
    subtasks: List[TravelSubTask]
    is_greeting: bool
import json
import os
from typing import Optional

from autogen_core.models import UserMessage, SystemMessage, AssistantMessage
from autogen_ext.models.openai import AzureOpenAIChatCompletionClient

# Create the client with type-checked environment variables

client = AzureOpenAIChatCompletionClient(
    azure_deployment=os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME"),
    model=os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME"),
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
)

from pprint import pprint

# Define the user message

messages = [
    SystemMessage(content="""You are an planner agent.
    Your job is to decide which agents to run based on the user's request.
    Below are the available agents specialised in different tasks:
    - FlightBooking: For booking flights and providing flight information
    - HotelBooking: For booking hotels and providing hotel information
    - CarRental: For booking cars and providing car rental information
    - ActivitiesBooking: For booking activities and providing activity information
    - DestinationInfo: For providing information about destinations
    - DefaultAgent: For handling general requests""", source="system"),
    UserMessage(content="Create a travel plan for a family of 2 kids from Singapore to Melbourne", source="user"),
]

response = await client.create(messages=messages, extra_create_args={"response_format": TravelPlan})

# Ensure the response content is a valid JSON string before loading it

response_content: Optional[str] = response.content if isinstance(response.content, str) else None
if response_content is None:
    raise ValueError("Response content is not a valid JSON string")

# Print the response content after loading it as JSON

pprint(json.loads(response_content))
```

위 코드에서 생성된 출력은 `assigned_agent`로 라우팅하고 최종 사용자에게 여행 계획을 요약하는 데 사용할 수 있습니다.

```json
{
    "is_greeting": "False",
    "main_task": "Plan a family trip from Singapore to Melbourne.",
    "subtasks": [
        {
            "assigned_agent": "flight_booking",
            "task_details": "Book round-trip flights from Singapore to Melbourne."
        },
        {
            "assigned_agent": "hotel_booking",
            "task_details": "Find family-friendly hotels in Melbourne."
        },
        {
            "assigned_agent": "car_rental",
            "task_details": "Arrange a car rental suitable for a family of four in Melbourne."
        },
        {
            "assigned_agent": "activities_booking",
            "task_details": "List family-friendly activities in Melbourne."
        },
        {
            "assigned_agent": "destination_info",
            "task_details": "Provide information about Melbourne as a travel destination."
        }
    ]
}
```

위 코드 샘플이 포함된 예제 노트북은 [여기](../../../07-planning-design/code_samples/07-autogen.ipynb)에서 확인할 수 있습니다.

### 반복적 계획

일부 작업은 상호작용이나 재계획이 필요하며, 한 하위 작업의 결과가 다음 작업에 영향을 미칠 수 있습니다. 예를 들어, 에이전트가 항공편 예약 중 예기치 않은 데이터 형식을 발견하면, 호텔 예약으로 넘어가기 전에 전략을 조정해야 할 수 있습니다.

또한, 사용자 피드백(예: 사용자가 더 이른 항공편을 선호한다고 결정하는 경우)은 부분적인 재계획을 유발할 수 있습니다. 이러한 동적이고 반복적인 접근 방식은 최종 솔루션이 현실적인 제약 조건과 변화하는 사용자 선호도에 맞도록 보장합니다.

예제 코드:

    ```python
    from autogen_core.models import UserMessage, SystemMessage, AssistantMessage
    #.. same as previous code and pass on the user history, current plan
    messages = [
        SystemMessage(content="""You are a planner agent to optimize the
        Your job is to decide which agents to run based on the user's request.
        Below are the available agents specialised in different tasks:
        - FlightBooking: For booking flights and providing flight information
        - HotelBooking: For booking hotels and providing hotel information
        - CarRental: For booking cars and providing car rental information
        - ActivitiesBooking: For booking activities and providing activity information
        - DestinationInfo: For providing information about destinations
        - DefaultAgent: For handling general requests""", source="system"),
        UserMessage(content="Create a travel plan for a family of 2 kids from Singapore to Melboune", source="user"),
        AssistantMessage(content=f"Previous travel plan - {TravelPlan}", source="assistant")
    ]
    # .. re-plan and send the tasks to respective agents
    ```

더 포괄적인 계획에 대해 알아보려면 복잡한 작업 해결을 위한 Magnetic One [블로그 글](https://www.microsoft.com/research/articles/magentic-one-a-generalist-multi-agent-system-for-solving-complex-tasks)을 확인하세요.

## 요약

이 글에서는 가용한 에이전트를 동적으로 선택할 수 있는 플래너를 생성하는 방법의 예를 살펴보았습니다. 플래너의 출력은 작업을 세분화하고 에이전트에게 할당하여 실행되도록 합니다. 에이전트가 작업을 수행하는 데 필요한 기능/도구에 액세스할 수 있다고 가정합니다. 에이전트 외에도 반영, 요약, 라운드 로빈 채팅과 같은 패턴을 추가하여 더욱 맞춤화할 수 있습니다.

## 추가 자료

* O1 추론 모델은 복잡한 작업 계획에서 매우 뛰어난 성능을 입증했습니다 - TODO: 예제 공유?

* Autogen Magnetic One - 복잡한 작업을 해결하기 위한 범용 다중 에이전트 시스템으로, 다양한 도전적인 에이전트 벤치마크에서 인상적인 결과를 달성했습니다. 참고: [autogen-magentic-one](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-magentic-one). 이 구현에서는 오케스트레이터가 작업별 계획을 생성하고 이러한 작업을 사용 가능한 에이전트에 위임합니다. 계획 외에도 오케스트레이터는 작업 진행 상황을 모니터링하고 필요에 따라 재계획하는 추적 메커니즘도 활용합니다.
```

**면책 조항**:
이 문서는 AI 기반 기계 번역 서비스를 사용하여 번역되었습니다. 정확성을 위해 노력하고 있지만, 자동 번역에는 오류나 부정확성이 포함될 수 있습니다. 원본 문서를 해당 언어로 작성된 상태에서 권위 있는 자료로 간주해야 합니다. 중요한 정보의 경우, 전문 번역가에 의한 번역을 권장합니다. 이 번역 사용으로 인해 발생하는 오해나 잘못된 해석에 대해서는 책임을 지지 않습니다.


# 다중 에이전트 설계 패턴

여러 에이전트가 포함된 프로젝트를 시작하면, 다중 에이전트 설계 패턴을 고려해야 합니다. 그러나 언제 다중 에이전트로 전환해야 하는지와 그 장점이 무엇인지 바로 명확하지 않을 수 있습니다.

## 소개

이번 강의에서는 다음 질문에 답하려고 합니다:

- 다중 에이전트가 적용될 수 있는 시나리오는 무엇인가요?
- 하나의 에이전트가 여러 작업을 수행하는 대신 다중 에이전트를 사용하는 것의 장점은 무엇인가요?
- 다중 에이전트 설계 패턴을 구현하기 위한 구성 요소는 무엇인가요?
- 여러 에이전트가 서로 어떻게 상호작용하는지에 대한 가시성을 어떻게 확보할 수 있을까요?

## 학습 목표

이 강의를 마친 후, 여러분은 다음을 할 수 있어야 합니다:

- 다중 에이전트가 적용 가능한 시나리오를 식별할 수 있다.
- 단일 에이전트보다 다중 에이전트를 사용하는 장점을 이해할 수 있다.
- 다중 에이전트 설계 패턴을 구현하기 위한 구성 요소를 이해할 수 있다.

큰 그림은 무엇일까요?

*다중 에이전트는 여러 에이전트가 협력하여 공통 목표를 달성하도록 하는 설계 패턴입니다.*

이 패턴은 로봇공학, 자율 시스템, 분산 컴퓨팅 등 다양한 분야에서 널리 사용됩니다.

## 다중 에이전트가 적용 가능한 시나리오

그렇다면 어떤 시나리오가 다중 에이전트를 사용하는 좋은 사례일까요? 답은 많습니다. 특히 다음과 같은 경우에 다중 에이전트를 사용하는 것이 유용합니다:

- **대규모 작업량**: 대규모 작업량은 더 작은 작업으로 나누어져 서로 다른 에이전트에 할당될 수 있습니다. 이를 통해 병렬 처리가 가능하며 작업을 더 빠르게 완료할 수 있습니다. 예를 들어, 대규모 데이터 처리 작업이 이에 해당합니다.
- **복잡한 작업**: 복잡한 작업도 대규모 작업처럼 더 작은 하위 작업으로 나누어지고, 각 하위 작업은 특정 측면을 전문으로 하는 서로 다른 에이전트에 할당될 수 있습니다. 예를 들어, 자율 주행 차량의 경우 각 에이전트가 내비게이션, 장애물 감지, 다른 차량과의 통신을 관리합니다.
- **다양한 전문성**: 서로 다른 에이전트가 다양한 전문성을 가지고 있어 단일 에이전트보다 작업의 다양한 측면을 더 효과적으로 처리할 수 있습니다. 예를 들어, 의료 분야에서는 진단, 치료 계획, 환자 모니터링을 각각 관리하는 에이전트를 사용할 수 있습니다.

## 단일 에이전트보다 다중 에이전트를 사용하는 장점

단일 에이전트 시스템은 간단한 작업에는 적합할 수 있지만, 더 복잡한 작업에서는 다중 에이전트를 사용하는 것이 여러 가지 장점을 제공합니다:

- **전문화**: 각 에이전트는 특정 작업에 특화될 수 있습니다. 단일 에이전트가 전문화되지 않으면 모든 작업을 처리할 수는 있지만, 복잡한 작업에서는 혼란을 겪을 수 있습니다. 예를 들어, 적합하지 않은 작업을 수행할 수도 있습니다.
- **확장성**: 단일 에이전트를 과부하시키는 대신 에이전트를 추가하여 시스템을 확장하는 것이 더 쉽습니다.
- **내결함성**: 하나의 에이전트가 실패하더라도 다른 에이전트가 계속 작동하여 시스템 신뢰성을 보장할 수 있습니다.

예를 들어, 사용자의 여행 예약을 생각해 봅시다. 단일 에이전트 시스템은 항공편 검색부터 호텔 예약, 렌터카 예약까지 모든 작업을 처리해야 합니다. 이를 단일 에이전트로 구현하려면 모든 작업을 처리할 수 있는 도구가 필요하며, 이는 유지 관리와 확장이 어려운 복잡하고 단일화된 시스템으로 이어질 수 있습니다. 반면, 다중 에이전트 시스템에서는 항공편 검색, 호텔 예약, 렌터카 예약을 각각 전문으로 하는 에이전트를 사용할 수 있습니다. 이렇게 하면 시스템이 더 모듈화되고 유지 관리가 용이하며 확장 가능해집니다.

이를 소규모 가족 운영 여행사와 프랜차이즈 여행사를 비교해 볼 수 있습니다. 소규모 가족 운영 여행사는 모든 작업을 단일 에이전트가 처리하지만, 프랜차이즈 여행사는 각 작업을 전문으로 하는 여러 에이전트가 처리합니다.

## 다중 에이전트 설계 패턴 구현의 구성 요소

다중 에이전트 설계 패턴을 구현하기 전에 패턴을 구성하는 요소를 이해해야 합니다.

사용자의 여행 예약 예제를 다시 살펴보겠습니다. 이 경우, 구성 요소는 다음을 포함합니다:

- **에이전트 간 통신**: 항공편 검색, 호텔 예약, 렌터카 예약 에이전트는 사용자의 선호도와 제약 조건에 대한 정보를 공유하고 소통해야 합니다. 이를 위해 통신 프로토콜과 방법을 결정해야 합니다. 예를 들어, 항공편 검색 에이전트는 호텔 예약 에이전트와 소통하여 호텔이 항공편 날짜와 일치하도록 예약되었는지 확인해야 합니다. 즉, *어떤 에이전트가 정보를 공유하며, 어떻게 공유할지*를 결정해야 합니다.
- **조정 메커니즘**: 에이전트는 사용자의 선호도와 제약 조건을 충족하기 위해 작업을 조정해야 합니다. 사용자가 공항 근처 호텔을 선호하는 경우, 렌터카는 공항에서만 가능하다는 제약 조건이 있을 수 있습니다. 따라서 호텔 예약 에이전트는 렌터카 예약 에이전트와 협력하여 사용자의 선호도와 제약 조건을 충족해야 합니다. 즉, *에이전트가 작업을 어떻게 조정할지*를 결정해야 합니다.
- **에이전트 아키텍처**: 에이전트는 사용자의 상호작용에서 학습하고 결정을 내릴 내부 구조를 가져야 합니다. 예를 들어, 항공편 검색 에이전트는 사용자가 선호하는 항공편을 추천하기 위해 결정을 내릴 내부 구조를 가져야 합니다. 즉, *에이전트가 사용자와의 상호작용에서 어떻게 학습하고 결정을 내릴지*를 결정해야 합니다. 예를 들어, 항공편 검색 에이전트는 사용자의 과거 선호도를 기반으로 항공편을 추천하는 기계 학습 모델을 사용할 수 있습니다.
- **다중 에이전트 상호작용에 대한 가시성**: 여러 에이전트가 서로 어떻게 상호작용하는지에 대한 가시성을 확보해야 합니다. 이를 위해 에이전트 활동과 상호작용을 추적하기 위한 도구와 기술이 필요합니다. 이는 로깅 및 모니터링 도구, 시각화 도구, 성능 지표의 형태로 제공될 수 있습니다.
- **다중 에이전트 패턴**: 중앙 집중식, 분산식, 하이브리드 아키텍처와 같은 다양한 다중 에이전트 시스템 구현 패턴이 있습니다. 사용 사례에 가장 적합한 패턴을 선택해야 합니다.
- **사용자 개입**: 대부분의 경우, 사용자가 개입할 시점을 에이전트에게 지시해야 합니다. 예를 들어, 사용자가 에이전트가 추천하지 않은 특정 호텔이나 항공편을 요청하거나 예약 전에 확인을 요청하는 경우가 이에 해당합니다.

## 다중 에이전트 상호작용에 대한 가시성

여러 에이전트가 서로 어떻게 상호작용하는지에 대한 가시성을 확보하는 것은 중요합니다. 이는 디버깅, 최적화, 전체 시스템의 효과성을 보장하는 데 필수적입니다. 이를 위해 에이전트 활동과 상호작용을 추적하기 위한 도구와 기술이 필요합니다. 이는 로깅 및 모니터링 도구, 시각화 도구, 성능 지표의 형태로 제공될 수 있습니다.

예를 들어, 사용자의 여행 예약의 경우, 각 에이전트의 상태, 사용자의 선호도와 제약 조건, 에이전트 간 상호작용을 보여주는 대시보드를 가질 수 있습니다. 이 대시보드는 사용자의 여행 날짜, 항공편 에이전트가 추천한 항공편, 호텔 에이전트가 추천한 호텔, 렌터카 에이전트가 추천한 렌터카를 보여줄 수 있습니다. 이를 통해 에이전트가 서로 어떻게 상호작용하고 있는지, 사용자의 선호도와 제약 조건이 충족되고 있는지를 명확히 파악할 수 있습니다.

각각의 측면을 더 자세히 살펴봅시다:

- **로깅 및 모니터링 도구**: 각 에이전트가 수행한 작업에 대해 로깅을 수행해야 합니다. 로그 항목에는 작업을 수행한 에이전트, 수행된 작업, 작업 수행 시간, 작업 결과에 대한 정보가 포함될 수 있습니다. 이 정보는 디버깅, 최적화 등에 사용될 수 있습니다.
- **시각화 도구**: 시각화 도구는 에이전트 간 상호작용을 더 직관적으로 볼 수 있도록 도와줍니다. 예를 들어, 에이전트 간 정보 흐름을 보여주는 그래프를 가질 수 있습니다. 이를 통해 병목 현상, 비효율성, 시스템 문제를 식별할 수 있습니다.
- **성능 지표**: 성능 지표는 다중 에이전트 시스템의 효과성을 추적하는 데 도움을 줍니다. 예를 들어, 작업 완료에 걸린 시간, 단위 시간당 완료된 작업 수, 에이전트가 제공한 추천의 정확도를 추적할 수 있습니다. 이를 통해 개선이 필요한 영역을 식별하고 시스템을 최적화할 수 있습니다.

## 다중 에이전트 패턴

다중 에이전트 앱을 만들기 위해 사용할 수 있는 몇 가지 구체적인 패턴을 살펴봅시다. 다음은 고려할 만한 흥미로운 패턴들입니다:

### 그룹 채팅

이 패턴은 여러 에이전트가 서로 소통할 수 있는 그룹 채팅 애플리케이션을 만들고자 할 때 유용합니다. 이 패턴의 일반적인 사용 사례로는 팀 협업, 고객 지원, 소셜 네트워킹 등이 있습니다.

이 패턴에서 각 에이전트는 그룹 채팅의 사용자로 나타나며, 메시지는 메시징 프로토콜을 사용하여 에이전트 간에 교환됩니다. 에이전트는 그룹 채팅에 메시지를 보내고, 그룹 채팅에서 메시지를 받고, 다른 에이전트의 메시지에 응답할 수 있습니다.

이 패턴은 모든 메시지가 중앙 서버를 통해 라우팅되는 중앙 집중식 아키텍처나 메시지가 직접 교환되는 분산 아키텍처로 구현될 수 있습니다.

![그룹 채팅](../../../translated_images/multi-agent-group-chat.82d537c5c8dc833abbd252033e60874bc9d00df7193888b3377f8426449a0b20.ko.png)

### 작업 이양

이 패턴은 여러 에이전트가 작업을 서로 이양할 수 있는 애플리케이션을 만들고자 할 때 유용합니다.

이 패턴의 일반적인 사용 사례로는 고객 지원, 작업 관리, 워크플로 자동화 등이 있습니다.

이 패턴에서 각 에이전트는 작업 또는 워크플로의 단계를 나타내며, 에이전트는 미리 정의된 규칙에 따라 작업을 다른 에이전트에게 이양할 수 있습니다.

![작업 이양](../../../translated_images/multi-agent-hand-off.ed4f0a5a58614a8a3e962fc476187e630a3ba309d066e460f017b503d0b84cfc.ko.png)

### 협업 필터링

이 패턴은 여러 에이전트가 협력하여 사용자에게 추천을 제공하는 애플리케이션을 만들고자 할 때 유용합니다.

왜 여러 에이전트가 협력해야 할까요? 각 에이전트가 다른 전문성을 가지고 있어 추천 과정에서 다양한 방식으로 기여할 수 있기 때문입니다.

예를 들어, 사용자가 주식 시장에서 구매할 최고의 주식에 대한 추천을 원한다고 가정해 봅시다.

- **산업 전문가**: 한 에이전트는 특정 산업의 전문가일 수 있습니다.
- **기술적 분석**: 다른 에이전트는 기술적 분석의 전문가일 수 있습니다.
- **기본적 분석**: 또 다른 에이전트는 기본적 분석의 전문가일 수 있습니다. 이러한 에이전트들이 협력하여 사용자에게 더 포괄적인 추천을 제공할 수 있습니다.

![추천](../../../translated_images/multi-agent-filtering.719217d169391ddb118bbb726b19d4d89ee139f960f8749ccb2400efb4d0ce79.ko.png)

## 시나리오: 환불 처리

고객이 제품 환불을 요청하는 시나리오를 고려해 봅시다. 이 과정에는 여러 에이전트가 관여할 수 있으며, 이를 특정 환불 프로세스 전용 에이전트와 다른 프로세스에도 사용할 수 있는 일반 에이전트로 나눌 수 있습니다.

**환불 프로세스 전용 에이전트**:

환불 프로세스에 관여할 수 있는 에이전트는 다음과 같습니다:

- **고객 에이전트**: 고객을 대표하며 환불 프로세스를 시작하는 역할을 합니다.
- **판매자 에이전트**: 판매자를 대표하며 환불을 처리하는 역할을 합니다.
- **결제 에이전트**: 결제 프로세스를 대표하며 고객의 결제를 환불하는 역할을 합니다.
- **해결 에이전트**: 해결 프로세스를 대표하며 환불 과정에서 발생하는 문제를 해결하는 역할을 합니다.
- **준수 에이전트**: 준수 프로세스를 대표하며 환불 과정이 규정과 정책을 준수하도록 보장하는 역할을 합니다.

**일반 에이전트**:

이 에이전트들은 비즈니스의 다른 부분에서도 사용할 수 있습니다.

- **배송 에이전트**: 배송 프로세스를 대표하며 제품을 판매자에게 다시 배송하는 역할을 합니다. 이 에이전트는 환불 프로세스뿐만 아니라 일반적인 제품 배송에도 사용할 수 있습니다.
- **피드백 에이전트**: 피드백 프로세스를 대표하며 고객의 피드백을 수집하는 역할을 합니다. 피드백은 환불 과정뿐만 아니라 언제든지 수집할 수 있습니다.
- **에스컬레이션 에이전트**: 에스컬레이션 프로세스를 대표하며 문제를 상위 지원 수준으로 전달하는 역할을 합니다. 이 유형의 에이전트는 문제를 에스컬레이션해야 하는 모든 프로세스에 사용할 수 있습니다.
- **알림 에이전트**: 알림 프로세스를 대표하며 환불 과정의 다양한 단계에서 고객에게 알림을 보내는 역할을 합니다.
- **분석 에이전트**: 분석 프로세스를 대표하며 환불 과정과 관련된 데이터를 분석하는 역할을 합니다.
- **감사 에이전트**: 감사 프로세스를 대표하며 환불 과정이 올바르게 수행되고 있는지 감사하는 역할을 합니다.
- **보고 에이전트**: 보고 프로세스를 대표하며 환불 과정에 대한 보고서를 생성하는 역할을 합니다.
- **지식 에이전트**: 지식 프로세스를 대표하며 환불 과정과 관련된 정보의 지식 기반을 유지하는 역할을 합니다. 이 에이전트는 환불뿐만 아니라 비즈니스의 다른 부분에 대한 지식을 보유할 수 있습니다.
- **보안 에이전트**: 보안 프로세스를 대표하며 환불 과정의 보안을 보장하는 역할을 합니다.
- **품질 에이전트**: 품질 프로세스를 대표하며 환불 과정의 품질을 보장하는 역할을 합니다.

위에서 나열된 에이전트는 환불 프로세스 전용 에이전트와 비즈니스의 다른 부분에서도 사용할 수 있는 일반 에이전트를 포함하여 꽤 많습니다. 이를 통해 다중 에이전트 시스템에서 사용할 에이전트를 결정하는 방법에 대한 아이디어를 얻을 수 있기를 바랍니다.

## 과제

이번 강의를 위한 좋은 과제는 무엇일까요?

고객 지원 프로세스를 위한 다중 에이전트 시스템을 설계하세요. 프로세스에 관여하는 에이전트, 각 에이전트의 역할과 책임, 에이전트 간의 상호작용 방식을 식별하세요. 고객 지원 프로세스에 특화된 에이전트와 비즈니스의 다른 부분에서도 사용할 수 있는 일반 에이전트를 모두 고려하세요.

> 아래 솔루션을 읽기 전에 스스로 생각해 보세요. 예상보다 더 많은 에이전트가 필요할 수 있습니다.

> TIP: 고객 지원 프로세스의 다양한 단계를 생각해 보고, 시스템에 필요한 에이전트도 고려하세요.

## 솔루션

[솔루션](./solution/solution.md)

## 지식 확인

질문: 언제 다중 에이전트를 고려해야 하나요?

- [] A1: 작업량이 적고 간단한 작업일 때
- [] A2: 작업량이 많을 때
- [] A3: 간단한 작업일 때

[퀴즈 솔루션](./solution/solution-quiz.md)

## 요약

이번 강의에서는 다중 에이전트 설계 패턴에 대해 살펴보았습니다. 다중 에이전트가 적용 가능한 시나리오, 단일 에이전트보다 다중 에이전트를 사용하는 장점, 다중 에이전트 설계 패턴을 구현하기 위한 구성 요소, 여러 에이전트 간 상호작용에 대한 가시성을 확보하는 방법 등을 다루었습니다.

## 추가 자료

- [Autogen design patterns](https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/design-patterns/intro.html)
- [Agentic design patterns](https://www.analyticsvidhya.com/blog/2024/10/agentic-design-patterns/)
```

**면책 조항**:
이 문서는 기계 기반 AI 번역 서비스를 사용하여 번역되었습니다. 정확성을 위해 노력하고 있지만, 자동 번역에는 오류나 부정확성이 포함될 수 있습니다. 원문이 작성된 언어의 문서를 신뢰할 수 있는 권위 있는 자료로 간주해야 합니다. 중요한 정보에 대해서는 전문적인 인간 번역을 권장합니다. 이 번역을 사용함으로써 발생하는 오해나 잘못된 해석에 대해 당사는 책임을 지지 않습니다.


# AI 에이전트의 메타인지
## 소개
AI 에이전트의 메타인지에 대한 수업에 오신 것을 환영합니다! 이 장은 AI 에이전트가 자신의 사고 과정을 어떻게 인식하고 평가할 수 있는지 궁금해하는 초보자를 위해 설계되었습니다. 이 수업이 끝날 때쯤에는 주요 개념을 이해하고 AI 에이전트 설계에 메타인지를 적용할 수 있는 실용적인 예제를 갖추게 될 것입니다.

## 학습 목표
이 수업을 완료한 후, 다음을 할 수 있습니다:
1. 에이전트 정의에서 추론 루프의 의미를 이해합니다.
2. 자기 수정 에이전트를 돕기 위한 계획 및 평가 기법을 사용합니다.
3. 작업을 수행하기 위해 코드를 조작할 수 있는 자신만의 에이전트를 만듭니다.

## 메타인지 소개
메타인지는 자신의 사고를 생각하는 고차원적인 인지 과정을 의미합니다. AI 에이전트의 경우, 이는 자기 인식과 과거 경험을 기반으로 자신의 행동을 평가하고 조정할 수 있는 능력을 의미합니다.

### 메타인지란 무엇인가?
메타인지, 즉 "생각에 대한 생각"은 자기 인식과 자신의 인지 과정을 자기 조절하는 고차원적인 인지 과정입니다. AI 분야에서 메타인지는 에이전트가 전략과 행동을 평가하고 적응할 수 있는 능력을 부여하여 문제 해결 및 의사 결정 능력을 향상시킵니다. 메타인지를 이해함으로써 더 지능적이고 적응 가능하며 효율적인 AI 에이전트를 설계할 수 있습니다.

### AI 에이전트에서 메타인지의 중요성
메타인지는 다음과 같은 이유로 AI 에이전트 설계에서 중요한 역할을 합니다:
![메타인지의 중요성](../../../translated_images/importance-of-metacognition.e351a5983bb745d60a1a60185391a39a6751d033c8c1948ceb6ad04eff7dbeac.ko.png)
- **자기 성찰**: 에이전트는 자신의 성과를 평가하고 개선이 필요한 영역을 식별할 수 있습니다.
- **적응성**: 에이전트는 과거 경험과 변화하는 환경에 따라 전략을 수정할 수 있습니다.
- **오류 수정**: 에이전트는 오류를 자율적으로 감지하고 수정하여 더 정확한 결과를 제공합니다.
- **자원 관리**: 에이전트는 행동을 계획하고 평가하여 시간 및 계산 자원과 같은 자원의 사용을 최적화할 수 있습니다.

## AI 에이전트의 구성 요소
메타인지 프로세스를 다루기 전에 AI 에이전트의 기본 구성 요소를 이해하는 것이 중요합니다. AI 에이전트는 일반적으로 다음으로 구성됩니다:
- **페르소나**: 사용자와 상호 작용하는 방식을 정의하는 에이전트의 성격 및 특성.
- **도구**: 에이전트가 수행할 수 있는 기능 및 능력.
- **기술**: 에이전트가 보유한 지식과 전문성.

이 구성 요소는 특정 작업을 수행할 수 있는 "전문성 단위"를 만듭니다.

**예제**: 여행 에이전트를 고려해 보세요. 이 에이전트는 사용자의 여행 계획을 세울 뿐만 아니라 실시간 데이터 및 과거 고객 경험을 기반으로 경로를 조정합니다.

### 예제: 여행 에이전트 서비스에서의 메타인지
AI로 구동되는 여행 에이전트 서비스를 설계한다고 상상해보세요. 이 에이전트, "여행 에이전트,"는 사용자가 휴가를 계획하도록 돕습니다. 메타인지를 통합하기 위해 여행 에이전트는 자기 인식과 과거 경험을 기반으로 자신의 행동을 평가하고 조정해야 합니다.

#### 현재 작업
현재 작업은 사용자가 파리로 여행을 계획하도록 돕는 것입니다.

#### 작업 완료 단계
1. **사용자 선호 수집**: 사용자에게 여행 날짜, 예산, 관심사(예: 박물관, 요리, 쇼핑), 특정 요구 사항에 대해 묻습니다.
2. **정보 검색**: 사용자의 선호에 맞는 항공편 옵션, 숙박 시설, 관광 명소 및 레스토랑을 검색합니다.
3. **추천 생성**: 항공편 세부 정보, 호텔 예약 및 제안된 활동이 포함된 개인 맞춤형 일정표를 제공합니다.
4. **피드백에 따라 조정**: 추천에 대한 사용자 피드백을 요청하고 필요한 조정을 합니다.

#### 필요한 자원
- 항공편 및 호텔 예약 데이터베이스에 대한 액세스.
- 파리 관광 명소 및 레스토랑에 대한 정보.
- 이전 상호작용에서의 사용자 피드백 데이터.

#### 경험 및 자기 성찰
여행 에이전트는 성과를 평가하고 과거 경험에서 학습하기 위해 메타인지를 사용합니다. 예를 들어:
1. **사용자 피드백 분석**: 여행 에이전트는 사용자가 긍정적으로 평가한 추천과 그렇지 않은 추천을 검토합니다. 그리고 이를 기반으로 미래의 제안을 조정합니다.
2. **적응성**: 사용자가 이전에 붐비는 장소를 싫어한다고 언급한 경우, 여행 에이전트는 향후 혼잡한 관광지를 피크 시간대에 추천하지 않습니다.
3. **오류 수정**: 과거에 예약이 꽉 찬 호텔을 추천하는 오류를 범했다면, 여행 에이전트는 추천을 하기 전에 가용성을 더 철저히 확인하도록 학습합니다.

#### 실용적인 개발자 예제
다음은 메타인지를 통합할 때 여행 에이전트 코드가 어떻게 보일 수 있는지에 대한 간단한 예입니다:
```python
class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        # Search for flights, hotels, and attractions based on preferences
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        # Analyze feedback and adjust future recommendations
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Example usage
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)
```

#### 메타인지가 중요한 이유
- **자기 성찰**: 에이전트는 성과를 분석하고 개선이 필요한 영역을 식별할 수 있습니다.
- **적응성**: 에이전트는 피드백과 변화하는 조건에 따라 전략을 수정할 수 있습니다.
- **오류 수정**: 에이전트는 자율적으로 실수를 감지하고 수정할 수 있습니다.
- **자원 관리**: 에이전트는 시간 및 계산 자원과 같은 자원의 사용을 최적화할 수 있습니다.

메타인지를 통합함으로써, 여행 에이전트는 더 개인화되고 정확한 여행 추천을 제공하여 전체 사용자 경험을 향상시킬 수 있습니다.

---

## 2. 에이전트의 계획
계획은 AI 에이전트 행동의 중요한 구성 요소입니다. 계획에는 현재 상태, 자원 및 가능한 장애물을 고려하여 목표를 달성하기 위한 단계를 개략적으로 설명하는 것이 포함됩니다.

### 계획의 요소
- **현재 작업**: 작업을 명확히 정의합니다.
- **작업 완료 단계**: 작업을 관리 가능한 단계로 세분화합니다.
- **필요한 자원**: 필요한 자원을 식별합니다.
- **경험**: 계획을 알리기 위해 과거 경험을 활용합니다.

**예제**: 여행 에이전트가 사용자의 여행 계획을 효과적으로 돕기 위해 수행해야 하는 단계는 다음과 같습니다:

### 여행 에이전트를 위한 단계
1. **사용자 선호 수집**
   - 사용자에게 여행 날짜, 예산, 관심사 및 특정 요구 사항에 대한 세부 정보를 요청합니다.
   - 예: "언제 여행을 계획 중이신가요?" "예산 범위는 얼마인가요?" "휴가에서 어떤 활동을 즐기시나요?"
2. **정보 검색**
   - 사용자 선호를 기반으로 관련 여행 옵션을 검색합니다.
   - **항공편**: 사용자의 예산 및 선호하는 여행 날짜 내에서 이용 가능한 항공편을 찾습니다.
   - **숙박 시설**: 위치, 가격, 편의 시설에 대한 사용자의 선호와 일치하는 호텔 또는 렌탈 숙소를 찾습니다.
   - **관광 명소 및 레스토랑**: 사용자의 관심사에 맞는 인기 관광 명소, 활동 및 식사 옵션을 식별합니다.
3. **추천 생성**
   - 검색된 정보를 개인 맞춤형 일정표로 컴파일합니다.
   - 사용자 선호에 맞게 추천을 조정하여 항공편 옵션, 호텔 예약 및 제안된 활동 세부 정보를 제공합니다.
4. **일정표를 사용자에게 제시**
   - 제안된 일정표를 사용자에게 공유하여 검토를 요청합니다.
   - 예: "여기 파리 여행을 위한 제안된 일정표가 있습니다. 항공편 세부 정보, 호텔 예약 및 추천 활동 목록이 포함되어 있습니다. 의견을 알려주세요!"
5. **피드백 수집**
   - 제안된 일정표에 대한 사용자 피드백을 요청합니다.
   - 예: "항공편 옵션이 마음에 드시나요?" "호텔이 필요에 적합한가요?" "추가하거나 제거하고 싶은 활동이 있나요?"
6. **피드백에 따라 조정**
   - 사용자의 피드백을 기반으로 일정표를 수정합니다.
   - 사용자 선호에 더 잘 맞도록 항공편, 숙박 및 활동 추천을 변경합니다.
7. **최종 확인**
   - 업데이트된 일정표를 사용자에게 최종 확인을 위해 제시합니다.
   - 예: "피드백을 기반으로 조정을 완료했습니다. 업데이트된 일정표입니다. 모두 괜찮으신가요?"
8. **예약 및 확인**
   - 사용자가 일정표를 승인하면 항공편, 숙박 시설 및 사전 계획된 활동 예약을 진행합니다.
   - 확인 세부 정보를 사용자에게 보냅니다.
9. **지속적인 지원 제공**
   - 여행 전후에 사용자의 변경 요청이나 추가 요청을 돕기 위해 대기합니다.
   - 예: "여행 중 추가 도움이 필요하시면 언제든지 연락 주세요!"

### 예제 상호작용
```python
class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Example usage within a booing request
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)
```
```
```markdown
여행 에이전트는 사용자 피드백을 기반으로 새로운 검색 쿼리를 작성합니다.
- 예: ```python
       if "disliked" in feedback:
           preferences["avoid"] = feedback["disliked"]
       ```
- **도구**: 여행 에이전트는 알고리즘을 사용하여 새로운 검색 결과를 순위 매기고 필터링하며, 사용자 피드백을 기반으로 관련성을 강조합니다.
- 예: ```python
       new_attractions = search_attractions(preferences)
       new_itinerary = create_itinerary(flights, hotels, new_attractions)
       print("Updated Itinerary:", new_itinerary)
       ```
- **평가**: 여행 에이전트는 사용자 피드백을 분석하고 필요한 조정을 수행하여 추천의 관련성과 정확성을 지속적으로 평가합니다.
- 예: ```python
       def adjust_preferences(preferences, feedback):
           if "liked" in feedback:
               preferences["favorites"] = feedback["liked"]
           if "disliked" in feedback:
               preferences["avoid"] = feedback["disliked"]
           return preferences

       preferences = adjust_preferences(preferences, feedback)
       ```

#### 실용적인 예
다음은 여행 에이전트에서 Corrective RAG 접근 방식을 통합한 간단한 Python 코드 예제입니다:
```python
class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)
        new_itinerary = self.generate_recommendations()
        return new_itinerary

# Example usage
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
new_itinerary = travel_agent.adjust_based_on_feedback(feedback)
print("Updated Itinerary:", new_itinerary)
```

### 사전 컨텍스트 로드
사전 컨텍스트 로드는 쿼리를 처리하기 전에 관련 컨텍스트 또는 배경 정보를 모델에 로드하는 것을 포함합니다. 이는 모델이 프로세스 중에 추가 데이터를 검색할 필요 없이 더 많은 정보를 바탕으로 응답을 생성할 수 있도록 도와줍니다.

다음은 Python에서 여행 에이전트 애플리케이션에 사전 컨텍스트 로드를 구현하는 간단한 예입니다:
```python
class TravelAgent:
    def __init__(self):
        # Pre-load popular destinations and their information
        self.context = {
            "Paris": {"country": "France", "currency": "Euro", "language": "French", "attractions": ["Eiffel Tower", "Louvre Museum"]},
            "Tokyo": {"country": "Japan", "currency": "Yen", "language": "Japanese", "attractions": ["Tokyo Tower", "Shibuya Crossing"]},
            "New York": {"country": "USA", "currency": "Dollar", "language": "English", "attractions": ["Statue of Liberty", "Times Square"]},
            "Sydney": {"country": "Australia", "currency": "Dollar", "language": "English", "attractions": ["Sydney Opera House", "Bondi Beach"]}
        }

    def get_destination_info(self, destination):
        # Fetch destination information from pre-loaded context
        info = self.context.get(destination)
        if info:
            return f"{destination}:\nCountry: {info['country']}\nCurrency: {info['currency']}\nLanguage: {info['language']}\nAttractions: {', '.join(info['attractions'])}"
        else:
            return f"Sorry, we don't have information on {destination}."

# Example usage
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))
```

#### 설명
1. **초기화 (`__init__` method)**: The `TravelAgent` class pre-loads a dictionary containing information about popular destinations such as Paris, Tokyo, New York, and Sydney. This dictionary includes details like the country, currency, language, and major attractions for each destination.

2. **Retrieving Information (`get_destination_info` method)**: When a user queries about a specific destination, the `get_destination_info` 메서드)**: 이 메서드는 미리 로드된 컨텍스트 사전에서 관련 정보를 검색합니다. 컨텍스트를 미리 로드함으로써, 여행 에이전트 애플리케이션은 실시간으로 외부 소스에서 이 정보를 검색할 필요 없이 사용자 쿼리에 빠르게 응답할 수 있습니다. 이는 애플리케이션을 더 효율적이고 응답성이 높게 만듭니다.

### 목표를 설정한 계획 부트스트래핑 후 반복
목표를 설정한 계획 부트스트래핑은 명확한 목표 또는 원하는 결과를 염두에 두고 시작하는 것을 포함합니다. 이 목표를 사전에 정의함으로써, 모델은 반복 과정 내내 이를 안내 원칙으로 사용할 수 있습니다. 이는 각 반복이 원하는 결과 달성에 한 걸음 더 가까워지도록 보장하여 프로세스를 더 효율적이고 집중되게 만듭니다.

다음은 Python에서 여행 에이전트에 대해 목표를 설정한 여행 계획을 부트스트래핑하는 예입니다:

### 시나리오
여행 에이전트는 고객을 위해 맞춤형 휴가를 계획하려고 합니다. 목표는 고객의 선호도와 예산을 기반으로 고객 만족도를 극대화하는 여행 일정을 만드는 것입니다.

### 단계
1. 고객의 선호도와 예산을 정의합니다.
2. 이러한 선호도를 기반으로 초기 계획을 부트스트래핑합니다.
3. 고객의 만족도를 최적화하기 위해 계획을 반복적으로 개선합니다.

#### Python 코드
```python
class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def bootstrap_plan(self, preferences, budget):
        plan = []
        total_cost = 0

        for destination in self.destinations:
            if total_cost + destination['cost'] <= budget and self.match_preferences(destination, preferences):
                plan.append(destination)
                total_cost += destination['cost']

        return plan

    def match_preferences(self, destination, preferences):
        for key, value in preferences.items():
            if destination.get(key) != value:
                return False
        return True

    def iterate_plan(self, plan, preferences, budget):
        for i in range(len(plan)):
            for destination in self.destinations:
                if destination not in plan and self.match_preferences(destination, preferences) and self.calculate_cost(plan, destination) <= budget:
                    plan[i] = destination
                    break
        return plan

    def calculate_cost(self, plan, new_destination):
        return sum(destination['cost'] for destination in plan) + new_destination['cost']

# Example usage
destinations = [
    {"name": "Paris", "cost": 1000, "activity": "sightseeing"},
    {"name": "Tokyo", "cost": 1200, "activity": "shopping"},
    {"name": "New York", "cost": 900, "activity": "sightseeing"},
    {"name": "Sydney", "cost": 1100, "activity": "beach"},
]

preferences = {"activity": "sightseeing"}
budget = 2000

travel_agent = TravelAgent(destinations)
initial_plan = travel_agent.bootstrap_plan(preferences, budget)
print("Initial Plan:", initial_plan)

refined_plan = travel_agent.iterate_plan(initial_plan, preferences, budget)
print("Refined Plan:", refined_plan)
```

#### 코드 설명
1. **초기화 (`__init__` method)**: The `TravelAgent` class is initialized with a list of potential destinations, each having attributes like name, cost, and activity type.

2. **Bootstrapping the Plan (`bootstrap_plan` method)**: This method creates an initial travel plan based on the client's preferences and budget. It iterates through the list of destinations and adds them to the plan if they match the client's preferences and fit within the budget.

3. **Matching Preferences (`match_preferences` method)**: This method checks if a destination matches the client's preferences.

4. **Iterating the Plan (`iterate_plan` method)**: This method refines the initial plan by trying to replace each destination in the plan with a better match, considering the client's preferences and budget constraints.

5. **Calculating Cost (`calculate_cost` 메서드)**: 이 메서드는 현재 계획의 총 비용(새로운 목적지를 포함할 수 있음)을 계산합니다.

#### 예제 사용법
- **초기 계획**: 여행 에이전트는 고객의 관광 선호도와 $2000의 예산을 기반으로 초기 계획을 생성합니다.
- **개선된 계획**: 여행 에이전트는 계획을 반복적으로 개선하여 고객의 선호도와 예산을 최적화합니다.

목표(예: 고객 만족 극대화)를 명확히 설정한 상태에서 계획을 부트스트래핑하고 이를 개선하기 위해 반복함으로써, 여행 에이전트는 고객을 위한 맞춤형 최적화된 여행 일정을 생성할 수 있습니다. 이 접근 방식은 여행 계획이 처음부터 고객의 선호도와 예산에 부합하도록 보장하며, 각 반복마다 개선됩니다.

### LLM을 활용한 재순위 매기기 및 점수화
대규모 언어 모델(LLM)은 검색된 문서나 생성된 응답의 관련성과 품질을 평가하여 재순위 매기기 및 점수화에 사용될 수 있습니다. 다음은 그 작동 방식입니다:

**검색:** 초기 검색 단계는 쿼리를 기반으로 후보 문서나 응답 세트를 가져옵니다.
**재순위 매기기:** LLM은 이러한 후보를 평가하고 관련성과 품질에 따라 재순위를 매깁니다. 이 단계는 가장 관련성이 높고 품질이 좋은 정보가 먼저 제공되도록 보장합니다.
**점수화:** LLM은 각 후보에게 관련성과 품질을 반영하는 점수를 할당합니다. 이는 사용자에게 가장 적합한 응답이나 문서를 선택하는 데 도움을 줍니다.

LLM을 재순위 매기기 및 점수화에 활용함으로써 시스템은 더 정확하고 맥락적으로 관련성 있는 정보를 제공하여 전체 사용자 경험을 개선할 수 있습니다.

다음은 여행 에이전트가 사용자 선호도를 기반으로 여행지를 재순위 매기고 점수화하기 위해 대규모 언어 모델(LLM)을 사용하는 방법의 예입니다:

#### 시나리오 - 선호도 기반 여행
여행 에이전트는 사용자 선호도를 기반으로 고객에게 최고의 여행지를 추천하고자 합니다. LLM은 여행지를 재순위 매기고 점수화하여 가장 관련성 높은 옵션을 제공하도록 도와줍니다.

#### 단계:
1. 사용자 선호도를 수집합니다.
2. 잠재적인 여행지 목록을 검색합니다.
3. LLM을 사용하여 사용자 선호도를 기반으로 여행지를 재순위 매기고 점수화합니다.

Azure OpenAI 서비스를 사용하여 이전 예제를 업데이트하는 방법은 다음과 같습니다:

#### 요구 사항
1. Azure 구독이 필요합니다.
2. Azure OpenAI 리소스를 생성하고 API 키를 가져옵니다.

#### Python 코드 예제
```python
import requests
import json

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def get_recommendations(self, preferences, api_key, endpoint):
        # Generate a prompt for the Azure OpenAI
        prompt = self.generate_prompt(preferences)

        # Define headers and payload for the request
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }

        # Call the Azure OpenAI API to get the re-ranked and scored destinations
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()

        # Extract and return the recommendations
        recommendations = response_data['choices'][0]['text'].strip().split('\n')
        return recommendations

    def generate_prompt(self, preferences):
        prompt = "Here are the travel destinations ranked and scored based on the following user preferences:\n"
        for key, value in preferences.items():
            prompt += f"{key}: {value}\n"
        prompt += "\nDestinations:\n"
        for destination in self.destinations:
            prompt += f"- {destination['name']}: {destination['description']}\n"
        return prompt

# Example usage
destinations = [
    {"name": "Paris", "description": "City of lights, known for its art, fashion, and culture."},
    {"name": "Tokyo", "description": "Vibrant city, famous for its modernity and traditional temples."},
    {"name": "New York", "description": "The city that never sleeps, with iconic landmarks and diverse culture."},
    {"name": "Sydney", "description": "Beautiful harbour city, known for its opera house and stunning beaches."},
]

preferences = {"activity": "sightseeing", "culture": "diverse"}
api_key = 'your_azure_openai_api_key'
endpoint = 'https://your-endpoint.com/openai/deployments/your-deployment-name/completions?api-version=2022-12-01'

travel_agent = TravelAgent(destinations)
recommendations = travel_agent.get_recommendations(preferences, api_key, endpoint)
print("Recommended Destinations:")
for rec in recommendations:
    print(rec)
```

#### 코드 설명 - 선호도 기반 추천
1. **초기화**: `TravelAgent` class is initialized with a list of potential travel destinations, each having attributes like name and description.

2. **Getting Recommendations (`get_recommendations` method)**: This method generates a prompt for the Azure OpenAI service based on the user's preferences and makes an HTTP POST request to the Azure OpenAI API to get re-ranked and scored destinations.

3. **Generating Prompt (`generate_prompt` method)**: This method constructs a prompt for the Azure OpenAI, including the user's preferences and the list of destinations. The prompt guides the model to re-rank and score the destinations based on the provided preferences.

4. **API Call**: The `requests` library is used to make an HTTP POST request to the Azure OpenAI API endpoint. The response contains the re-ranked and scored destinations.

5. **Example Usage**: The travel agent collects user preferences (e.g., interest in sightseeing and diverse culture) and uses the Azure OpenAI service to get re-ranked and scored recommendations for travel destinations.

Make sure to replace `your_azure_openai_api_key` with your actual Azure OpenAI API key and `https://your-endpoint.com/...`를 Azure OpenAI 배포의 실제 엔드포인트 URL로 대체합니다.

LLM을 재순위 매기기 및 점수화에 활용함으로써, 여행 에이전트는 고객에게 더 개인화되고 관련성 높은 여행 추천을 제공하여 전체 경험을 향상시킬 수 있습니다.
```
```markdown
파리 최고의 박물관?"). - **탐색 의도**: 사용자가 특정 웹사이트나 페이지로 이동하려고 함 (예: "루브르 박물관 공식 웹사이트"). - **거래 의도**: 사용자가 항공편 예약 또는 구매와 같은 거래를 수행하려고 함 (예: "파리행 항공편 예약"). 2. **컨텍스트 인식**: - 사용자의 쿼리 컨텍스트를 분석하면 의도를 정확하게 식별하는 데 도움이 됨. 여기에는 이전 상호작용, 사용자 선호도, 현재 쿼리의 세부 정보가 포함됨. 3. **자연어 처리 (NLP)**: - NLP 기술을 사용하여 사용자가 제공한 자연어 쿼리를 이해하고 해석함. 여기에는 엔터티 인식, 감정 분석, 쿼리 구문 분석과 같은 작업이 포함됨. 4. **개인화**: - 사용자의 기록, 선호도, 피드백을 기반으로 검색 결과를 개인화하면 검색된 정보의 관련성을 높일 수 있음. #### 실용적인 예: 여행 에이전트에서 의도를 활용한 검색 여행 에이전트를 예로 들어 의도를 활용한 검색이 어떻게 구현될 수 있는지 살펴보자. 1. **사용자 선호도 수집** ```python
   class Travel_Agent:
       def __init__(self):
           self.user_preferences = {}

       def gather_preferences(self, preferences):
           self.user_preferences = preferences
   ``` 2. **사용자 의도 이해** ```python
   def identify_intent(query):
       if "book" in query or "purchase" in query:
           return "transactional"
       elif "website" in query or "official" in query:
           return "navigational"
       else:
           return "informational"
   ``` 3. **컨텍스트 인식** ```python
   def analyze_context(query, user_history):
       # Combine current query with user history to understand context
       context = {
           "current_query": query,
           "user_history": user_history
       }
       return context
   ``` 4. **검색 및 결과 개인화** ```python
   def search_with_intent(query, preferences, user_history):
       intent = identify_intent(query)
       context = analyze_context(query, user_history)
       if intent == "informational":
           search_results = search_information(query, preferences)
       elif intent == "navigational":
           search_results = search_navigation(query)
       elif intent == "transactional":
           search_results = search_transaction(query, preferences)
       personalized_results = personalize_results(search_results, user_history)
       return personalized_results

   def search_information(query, preferences):
       # Example search logic for informational intent
       results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
       return results

   def search_navigation(query):
       # Example search logic for navigational intent
       results = search_web(query)
       return results

   def search_transaction(query, preferences):
       # Example search logic for transactional intent
       results = search_web(f"book {query} to {preferences['destination']}")
       return results

   def personalize_results(results, user_history):
       # Example personalization logic
       personalized = [result for result in results if result not in user_history]
       return personalized[:10]  # Return top 10 personalized results
   ``` 5. **예제 사용법** ```python
   travel_agent = Travel_Agent()
   preferences = {
       "destination": "Paris",
       "interests": ["museums", "cuisine"]
   }
   travel_agent.gather_preferences(preferences)
   user_history = ["Louvre Museum website", "Book flight to Paris"]
   query = "best museums in Paris"
   results = search_with_intent(query, preferences, user_history)
   print("Search Results:", results)
   ``` --- ## 4. 도구로서의 코드 생성 코드 생성 에이전트는 AI 모델을 사용하여 코드를 작성하고 실행하며 복잡한 문제를 해결하고 작업을 자동화함. ### 코드 생성 에이전트 코드 생성 에이전트는 생성적 AI 모델을 사용하여 코드를 작성하고 실행함. 이러한 에이전트는 다양한 프로그래밍 언어로 코드를 생성하고 실행하여 복잡한 문제를 해결하고 작업을 자동화하며 귀중한 통찰력을 제공할 수 있음. #### 실용적인 응용 1. **자동 코드 생성**: 데이터 분석, 웹 스크래핑, 기계 학습과 같은 특정 작업에 대한 코드 스니펫 생성. 2. **RAG로서의 SQL**: 데이터베이스에서 데이터를 검색하고 조작하기 위해 SQL 쿼리를 사용. 3. **문제 해결**: 알고리즘 최적화 또는 데이터 분석과 같은 특정 문제를 해결하기 위해 코드 생성 및 실행. #### 예제: 데이터 분석을 위한 코드 생성 에이전트 데이터 분석을 위한 코드 생성 에이전트를 설계한다고 가정해 보자. 작동 방식은 다음과 같음: 1. **작업**: 데이터셋을 분석하여 트렌드와 패턴을 식별. 2. **단계**: - 데이터셋을 데이터 분석 도구에 로드. - 데이터를 필터링하고 집계하기 위한 SQL 쿼리 생성. - 쿼리를 실행하고 결과를 검색. - 결과를 사용하여 시각화 및 인사이트 생성. 3. **필요한 리소스**: 데이터셋, 데이터 분석 도구, SQL 기능에 대한 접근. 4. **경험**: 이전 분석 결과를 사용하여 향후 분석의 정확성과 관련성을 향상. ### 예제: 여행 에이전트를 위한 코드 생성 에이전트 이번 예제에서는 사용자가 여행을 계획할 수 있도록 코드 생성 및 실행을 통해 지원하는 코드 생성 에이전트인 여행 에이전트를 설계함. 이 에이전트는 항공편 옵션 검색, 결과 필터링, 생성적 AI를 사용한 일정 작성과 같은 작업을 처리할 수 있음. #### 코드 생성 에이전트 개요 1. **사용자 선호도 수집**: 목적지, 여행 날짜, 예산, 관심사 등 사용자 입력을 수집. 2. **데이터 검색을 위한 코드 생성**: 항공편, 호텔, 명소에 대한 데이터를 검색하기 위한 코드 스니펫 생성. 3. **생성된 코드 실행**: 생성된 코드를 실행하여 실시간 정보를 검색. 4. **일정 생성**: 검색된 데이터를 개인화된 여행 계획으로 컴파일. 5. **피드백 기반 조정**: 사용자 피드백을 받고 필요하면 코드를 다시 생성하여 결과를 개선. #### 단계별 구현 1. **사용자 선호도 수집** ```python
   class Travel_Agent:
       def __init__(self):
           self.user_preferences = {}

       def gather_preferences(self, preferences):
           self.user_preferences = preferences
   ``` 2. **데이터 검색을 위한 코드 생성** ```python
   def generate_code_to_fetch_data(preferences):
       # Example: Generate code to search for flights based on user preferences
       code = f"""
       def search_flights():
           import requests
           response = requests.get('https://api.example.com/flights', params={preferences})
           return response.json()
       """
       return code

   def generate_code_to_fetch_hotels(preferences):
       # Example: Generate code to search for hotels
       code = f"""
       def search_hotels():
           import requests
           response = requests.get('https://api.example.com/hotels', params={preferences})
           return response.json()
       """
       return code
   ``` 3. **생성된 코드 실행** ```python
   def execute_code(code):
       # Execute the generated code using exec
       exec(code)
       result = locals()
       return result

   travel_agent = Travel_Agent()
   preferences = {
       "destination": "Paris",
       "dates": "2025-04-01 to 2025-04-10",
       "budget": "moderate",
       "interests": ["museums", "cuisine"]
   }
   travel_agent.gather_preferences(preferences)

   flight_code = generate_code_to_fetch_data(preferences)
   hotel_code = generate_code_to_fetch_hotels(preferences)

   flights = execute_code(flight_code)
   hotels = execute_code(hotel_code)

   print("Flight Options:", flights)
   print("Hotel Options:", hotels)
   ``` 4. **일정 생성** ```python
   def generate_itinerary(flights, hotels, attractions):
       itinerary = {
           "flights": flights,
           "hotels": hotels,
           "attractions": attractions
       }
       return itinerary

   attractions = search_attractions(preferences)
   itinerary = generate_itinerary(flights, hotels, attractions)
   print("Suggested Itinerary:", itinerary)
   ``` 5. **피드백 기반 조정** ```python
   def adjust_based_on_feedback(feedback, preferences):
       # Adjust preferences based on user feedback
       if "liked" in feedback:
           preferences["favorites"] = feedback["liked"]
       if "disliked" in feedback:
           preferences["avoid"] = feedback["disliked"]
       return preferences

   feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
   updated_preferences = adjust_based_on_feedback(feedback, preferences)

   # Regenerate and execute code with updated preferences
   updated_flight_code = generate_code_to_fetch_data(updated_preferences)
   updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)

   updated_flights = execute_code(updated_flight_code)
   updated_hotels = execute_code(updated_hotel_code)

   updated_itinerary = generate_itinerary(updated_flights, updated_hotels, attractions)
   print("Updated Itinerary:", updated_itinerary)
   ``` ### 환경 인식 및 추론 활용 테이블 스키마 기반으로 쿼리 생성 프로세스를 개선하기 위해 환경 인식 및 추론을 활용할 수 있음. 다음은 이를 구현하는 방법의 예임: 1. **스키마 이해**: 시스템이 테이블 스키마를 이해하고 이를 쿼리 생성에 반영. 2. **피드백 기반 조정**: 시스템이 피드백을 기반으로 사용자 선호도를 조정하고 스키마의 어떤 필드를 업데이트해야 하는지 추론. 3. **쿼리 생성 및 실행**: 새로운 선호도를 기반으로 업데이트된 항공편 및 호텔 데이터를 검색하기 위해 쿼리를 생성 및 실행. 다음은 이러한 개념을 통합한 업데이트된 Python 코드 예제임: ```python
def adjust_based_on_feedback(feedback, preferences, schema):
    # Adjust preferences based on user feedback
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Reasoning based on schema to adjust other related preferences
    for field in schema:
        if field in preferences:
            preferences[field] = adjust_based_on_environment(feedback, field, schema)
    return preferences

def adjust_based_on_environment(feedback, field, schema):
    # Custom logic to adjust preferences based on schema and feedback
    if field in feedback["liked"]:
        return schema[field]["positive_adjustment"]
    elif field in feedback["disliked"]:
        return schema[field]["negative_adjustment"]
    return schema[field]["default"]

def generate_code_to_fetch_data(preferences):
    # Generate code to fetch flight data based on updated preferences
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Generate code to fetch hotel data based on updated preferences
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # Simulate execution of code and return mock data
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Generate itinerary based on flights, hotels, and attractions
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# Example schema
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# Example usage
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# Regenerate and execute code with updated preferences
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)

updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)

updated_itinerary = generate_itinerary(updated_flights, updated_hotels, feedback["liked"])
print("Updated Itinerary:", updated_itinerary)
``` #### 설명 - 피드백 기반 예약 1. **스키마 인식**: `schema` dictionary defines how preferences should be adjusted based on feedback. It includes fields like `favorites` and `avoid`, with corresponding adjustments.
2. **Adjusting Preferences (`adjust_based_on_feedback` method)**: This method adjusts preferences based on user feedback and the schema.
3. **Environment-Based Adjustments (`adjust_based_on_environment` 메서드)**: 이 메서드는 스키마와 피드백을 기반으로 조정을 맞춤화. 4. **쿼리 생성 및 실행**: 조정된 선호도를 기반으로 업데이트된 항공편 및 호텔 데이터를 검색하기 위한 코드를 생성하고 이러한 쿼리 실행을 시뮬레이션. 5. **일정 생성**: 새로운 항공편, 호텔, 명소 데이터를 기반으로 업데이트된 일정을 생성. 시스템을 환경 인식적으로 만들고 스키마를 기반으로 추론함으로써 더 정확하고 관련성 높은 쿼리를 생성할 수 있으며, 이를 통해 더 나은 여행 추천과 개인화된 사용자 경험을 제공할 수 있음. ### RAG 기법으로서의 SQL 사용 SQL(구조적 질의 언어)은 데이터베이스와 상호작용하기 위한 강력한 도구임. RAG(Retrieval-Augmented Generation) 접근 방식의 일부로 사용될 때, SQL은 데이터베이스에서 관련 데이터를 검색하여 AI 에이전트의 응답 또는 작업을 알리고 생성하는 데 활용될 수 있음. 여행 에이전트의 맥락에서 SQL이 RAG 기법으로 어떻게 사용될 수 있는지 살펴보자. #### 핵심 개념 1. **데이터베이스 상호작용**: - SQL은 데이터베이스를 쿼리하고 관련 정보를 검색하며 데이터를 조작하는 데 사용됨. - 예: 항공편 세부 정보, 호텔 정보, 명소를 여행 데이터베이스에서 검색. 2. **RAG와의 통합**: - SQL 쿼리는 사용자 입력 및 선호도를 기반으로 생성됨. - 검색된 데이터는 개인화된 추천 또는 작업을 생성하는 데 사용됨. 3. **동적 쿼리 생성**: - AI 에이전트는 컨텍스트와 사용자 요구에 따라 동적인 SQL 쿼리를 생성. - 예: 예산, 날짜, 관심사를 기반으로 결과를 필터링하도록 SQL 쿼리를 맞춤화. #### 응용 - **자동 코드 생성**: 특정 작업에 대한 코드 스니펫 생성. - **RAG로서의 SQL**: 데이터를 조작하기 위해 SQL 쿼리를 사용. - **문제 해결**: 문제를 해결하기 위해 코드 생성 및 실행. **예제**: 데이터 분석 에이전트: 1. **작업**: 데이터셋을 분석하여 트렌드 찾기. 2. **단계**: - 데이터셋 로드. - 데이터를 필터링하기 위한 SQL 쿼리 생성. - 쿼리를 실행하고 결과 검색. - 시각화 및 인사이트 생성. 3. **리소스**: 데이터셋 접근, SQL 기능. 4. **경험**: 이전 결과를 사용하여 미래 분석 개선. #### 실용적인 예: 여행 에이전트에서 SQL 사용 1. **사용자 선호도 수집** ```python
   class Travel_Agent:
       def __init__(self):
           self.user_preferences = {}

       def gather_preferences(self, preferences):
           self.user_preferences = preferences
   ``` 2. **SQL 쿼리 생성** ```python
   def generate_sql_query(table, preferences):
       query = f"SELECT * FROM {table} WHERE "
       conditions = []
       for key, value in preferences.items():
           conditions.append(f"{key}='{value}'")
       query += " AND ".join(conditions)
       return query
   ``` 3. **SQL 쿼리 실행** ```python
   import sqlite3

   def execute_sql_query(query, database="travel.db"):
       connection = sqlite3.connect(database)
       cursor = connection.cursor()
       cursor.execute(query)
       results = cursor.fetchall()
       connection.close()
       return results
   ``` 4. **추천 생성** ```python
   def generate_recommendations(preferences):
       flight_query = generate_sql_query("flights", preferences)
       hotel_query = generate_sql_query("hotels", preferences)
       attraction_query = generate_sql_query("attractions", preferences)

       flights = execute_sql_query(flight_query)
       hotels = execute_sql_query(hotel_query)
       attractions = execute_sql_query(attraction_query)

       itinerary = {
           "flights": flights,
           "hotels": hotels,
           "attractions": attractions
       }
       return itinerary

   travel_agent = Travel_Agent()
   preferences = {
       "destination": "Paris",
       "dates": "2025-04-01 to 2025-04-10",
       "budget": "moderate",
       "interests": ["museums", "cuisine"]
   }
   travel_agent.gather_preferences(preferences)
   itinerary = generate_recommendations(preferences)
   print("Suggested Itinerary:", itinerary)
   ``` #### SQL 쿼리 예제 1. **항공편 쿼리** ```sql
   SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-10' AND budget='moderate';
   ``` 2. **호텔 쿼리** ```sql
   SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate';
   ``` 3. **명소 쿼리** ```sql
   SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';
   ``` SQL을 Retrieval-Augmented Generation(RAG) 기법의 일부로 활용하면 여행 에이전트와 같은 AI 에이전트가 관련 데이터를 동적으로 검색하고 활용하여 정확하고 개인화된 추천을 제공할 수 있음. ### 결론 메타인지(Metacognition)는 AI 에이전트의 기능을 크게 향상시킬 수 있는 강력한 도구임. 메타인지 프로세스를 통합함으로써 더 지능적이고 적응력이 뛰어나며 효율적인 에이전트를 설계할 수 있음. 추가 리소스를 사용하여 AI 에이전트의 메타인지라는 흥미로운 세계를 더 탐구해 보세요.
```

**면책 조항**:
이 문서는 기계 기반 AI 번역 서비스를 사용하여 번역되었습니다. 정확성을 위해 노력하고 있지만, 자동 번역에는 오류나 부정확성이 포함될 수 있음을 유의하시기 바랍니다. 원어로 작성된 원본 문서를 신뢰할 수 있는 권위 있는 자료로 간주해야 합니다. 중요한 정보의 경우, 전문 번역가에 의한 번역을 권장합니다. 이 번역 사용으로 인해 발생하는 오해나 잘못된 해석에 대해 당사는 책임을 지지 않습니다.


# 프로덕션 환경에서의 AI 에이전트

## 소개

이 강의에서는 다음을 다룹니다:

- AI 에이전트를 프로덕션 환경에 효과적으로 배포하는 방법.
- AI 에이전트를 프로덕션에 배포할 때 직면할 수 있는 일반적인 실수와 문제.
- 비용을 관리하면서도 AI 에이전트의 성능을 유지하는 방법.

## 학습 목표

이 강의를 완료한 후, 다음을 알게 되고 이해하게 됩니다:

- 프로덕션 환경에서 AI 에이전트 시스템의 성능, 비용, 효율성을 개선하는 기술.
- AI 에이전트를 평가하는 방법과 평가해야 할 요소.
- AI 에이전트를 프로덕션에 배포할 때 비용을 제어하는 방법.

신뢰할 수 있는 AI 에이전트를 배포하는 것이 중요합니다. "신뢰할 수 있는 AI 에이전트 구축" 강의도 확인해 보세요.

## AI 에이전트 평가하기

AI 에이전트를 배포하기 전, 배포 중, 그리고 배포 후에 적절한 평가 시스템을 갖추는 것은 매우 중요합니다. 이를 통해 시스템이 사용자와 여러분의 목표에 부합하는지 확인할 수 있습니다.

AI 에이전트를 평가하려면 에이전트의 출력뿐만 아니라 AI 에이전트가 운영되는 전체 시스템을 평가할 수 있는 능력이 중요합니다. 여기에는 다음이 포함되지만 이에 국한되지는 않습니다:

- 초기 모델 요청.
- 사용자의 의도를 파악하는 에이전트의 능력.
- 작업을 수행하기 위해 적합한 도구를 식별하는 에이전트의 능력.
- 에이전트의 요청에 대한 도구의 응답.
- 도구의 응답을 해석하는 에이전트의 능력.
- 에이전트의 응답에 대한 사용자의 피드백.

이러한 방식으로 개선이 필요한 영역을 보다 모듈식으로 식별할 수 있습니다. 이를 통해 모델, 프롬프트, 도구 및 기타 구성 요소에 대한 변경의 영향을 더 효율적으로 모니터링할 수 있습니다.

## AI 에이전트의 일반적인 문제와 잠재적 해결책

| **문제**                                    | **잠재적 해결책**                                                                                |
| ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| AI 에이전트가 일관되게 작업을 수행하지 않음 | - AI 에이전트에 제공되는 프롬프트를 다듬고 목표를 명확히 설정하세요.
- 작업을 하위 작업으로 나누고 여러 에이전트가 이를 처리하도록 하면 도움이 될 수 있는 부분을 식별하세요.                                              |
| AI 에이전트가 연속 루프에 빠짐              | - 프로세스를 종료해야 하는 명확한 조건과 종료 기준을 설정하세요.
- 추론 및 계획이 필요한 복잡한 작업의 경우, 추론 작업에 특화된 더 큰 모델을 사용하세요.                                                             |
| AI 에이전트의 도구 호출 성능이 저조함       | - 에이전트 시스템 외부에서 도구의 출력을 테스트하고 검증하세요.
- 정의된 매개변수, 프롬프트 및 도구의 명칭을 다듬으세요.                                                                                |
| 멀티 에이전트 시스템이 일관되게 작동하지 않음 | - 각 에이전트에 제공되는 프롬프트를 다듬어 구체적이고 서로 구별되도록 하세요.
- "라우팅" 또는 컨트롤러 에이전트를 사용하여 어떤 에이전트가 적합한지 결정하는 계층적 시스템을 구축하세요.                                |

## 비용 관리

AI 에이전트를 프로덕션 환경에 배포할 때 비용을 관리하기 위한 몇 가지 전략은 다음과 같습니다:

- **응답 캐싱** - 일반적인 요청과 작업을 식별하고, 이를 에이전트 시스템을 거치기 전에 미리 응답하도록 설정하는 것은 유사한 요청의 볼륨을 줄이는 좋은 방법입니다. 더 기본적인 AI 모델을 사용해 요청이 캐싱된 요청과 얼마나 유사한지 식별하는 흐름을 구현할 수도 있습니다.

- **소형 모델 사용** - 소형 언어 모델(SLM)은 특정 에이전트 사용 사례에서 우수한 성능을 발휘할 수 있으며, 비용을 상당히 절감할 수 있습니다. 앞서 언급했듯이, 평가 시스템을 구축하여 대형 모델과 성능을 비교하고 이를 통해 SLM이 사용 사례에서 얼마나 잘 작동하는지 이해하는 것이 가장 좋은 방법입니다.

- **라우터 모델 사용** - 유사한 전략으로 다양한 모델과 크기를 활용하는 방법이 있습니다. LLM/SLM 또는 서버리스 함수를 사용하여 요청의 복잡도에 따라 적합한 모델로 라우팅하면 비용을 절감하면서도 적절한 작업에서 성능을 유지할 수 있습니다.

## 축하합니다

이 강의는 "AI 에이전트 입문"의 마지막 강의입니다.

우리는 이 빠르게 성장하는 업계의 피드백과 변화를 반영하여 지속적으로 강의를 추가할 계획이므로, 가까운 미래에 다시 방문해 주세요.

AI 에이전트를 계속 학습하고 구축하고 싶다면, [Azure AI 커뮤니티 Discord](https://discord.gg/kzRShWzttr)에 참여하세요.

우리는 그곳에서 워크숍, 커뮤니티 라운드테이블, 그리고 "무엇이든 물어보세요" 세션을 진행합니다.

또한, 프로덕션 환경에서 AI 에이전트를 구축하는 데 도움을 줄 수 있는 추가 자료를 모아둔 학습 컬렉션도 제공하고 있습니다.

**면책 조항**:
이 문서는 기계 기반 AI 번역 서비스를 사용하여 번역되었습니다. 정확성을 위해 최선을 다하고 있지만, 자동 번역에는 오류나 부정확성이 포함될 수 있습니다. 원본 문서의 해당 언어 버전이 권위 있는 자료로 간주되어야 합니다. 중요한 정보에 대해서는 전문적인 인간 번역을 권장합니다. 이 번역 사용으로 인해 발생하는 오해나 잘못된 해석에 대해 당사는 책임을 지지 않습니다.


# Configuração do Curso

## Introdução

Nesta lição, veremos como executar os exemplos de código deste curso.

## Requisitos

- Uma conta no GitHub
- Python 3.12+

## Clonar ou Fazer Fork deste Repositório

Para começar, clone ou faça um fork do repositório no GitHub. Isso criará sua própria versão do material do curso, permitindo que você execute, teste e modifique o código!

Isso pode ser feito clicando no link para [fazer fork do repositório](https://github.com/microsoft/ai-agents-for-beginners/fork).

Agora você deve ter sua própria versão "forkada" deste curso, como mostrado abaixo:

![Repositório Forkado](../../../translated_images/forked-repo.eea246a73044cc984a1e462349e36e7336204f00785e3187b7399905feeada07.pt.png)

## Obtenha seu Token de Acesso Pessoal (PAT) do GitHub

Atualmente, este curso utiliza o Github Models Marketplace para oferecer acesso gratuito a Modelos de Linguagem de Grande Escala (LLMs) que serão usados para criar Agentes de IA.

Para acessar este serviço, você precisará criar um Token de Acesso Pessoal no GitHub.

Isso pode ser feito acessando as configurações de [Tokens de Acesso Pessoal](https://github.com/settings/personal-access-tokens) na sua conta do GitHub.

Selecione as opções `Fine-grained tokens` no lado esquerdo da sua tela.

Depois, selecione `Generate new token`.

![Gerar Token](../../../translated_images/generate-token.361ec40abe59b84ac68d63c23e2b6854d6fad82bd4e41feb98fc0e6f030e8ef7.pt.png)

Copie o novo token que você acabou de criar. Agora, adicione-o ao arquivo `.env` incluído neste curso.

## Adicione-o às Variáveis de Ambiente

Para criar seu arquivo `.env`, execute o comando abaixo no terminal:

```bash
cp .env.example .env
```

Isso copiará o arquivo de exemplo e criará um `.env` no seu diretório.

Abra o arquivo e cole o token que você criou no campo `GITHUB_TOKEN=` do arquivo .env.

## Instale os Pacotes Necessários

Para garantir que você tenha todos os pacotes Python necessários para executar o código, execute o comando abaixo no terminal.

Recomendamos criar um ambiente virtual Python para evitar conflitos e problemas.

```bash
pip install -r requirements.txt
```

Isso deve instalar os pacotes Python necessários.

Agora você está pronto para executar o código deste curso. Divirta-se aprendendo mais sobre o mundo dos Agentes de IA!

Se você tiver algum problema durante a configuração, participe do nosso [Discord da Comunidade Azure AI](https://discord.gg/kzRShWzttr) ou [crie um issue](https://github.com/microsoft/ai-agents-for-beginners/issues?WT.mc_id=academic-105485-koreyst).
```

**Aviso Legal**:
Este documento foi traduzido utilizando serviços de tradução baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte oficial. Para informações críticas, recomenda-se a tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.


# Introdução a Agentes de IA e Casos de Uso

Bem-vindo ao curso "Agentes de IA para Iniciantes"! Este curso fornece conhecimentos fundamentais e exemplos práticos para a construção de Agentes de IA.

Junte-se à [Comunidade do Discord do Azure AI](https://discord.gg/kzRShWzttr) para conhecer outros alunos, construtores de Agentes de IA e tirar quaisquer dúvidas que você tenha sobre este curso.

Para começar este curso, vamos primeiro entender melhor o que são os Agentes de IA e como podemos utilizá-los em aplicações e fluxos de trabalho que criamos.

## Introdução

Esta lição aborda:

- O que são Agentes de IA e quais são os diferentes tipos de agentes?
- Quais casos de uso são mais indicados para Agentes de IA e como eles podem nos ajudar?
- Quais são alguns dos componentes básicos ao projetar Soluções Agênticas?

## Objetivos de Aprendizado
Após concluir esta lição, você deverá ser capaz de:

- Compreender os conceitos de Agentes de IA e como eles diferem de outras soluções de IA.
- Aplicar Agentes de IA de maneira mais eficiente.
- Projetar soluções agênticas produtivamente para usuários e clientes.

## Definindo Agentes de IA e Tipos de Agentes de IA

### O que são Agentes de IA?

Agentes de IA são **sistemas** que permitem que **Modelos de Linguagem de Grande Escala (LLMs)** **executem ações** ao estender suas capacidades, dando aos LLMs **acesso a ferramentas** e **conhecimento**.

Vamos dividir essa definição em partes menores:

- **Sistema** - É importante pensar nos agentes não apenas como um único componente, mas como um sistema composto por muitos componentes. No nível básico, os componentes de um Agente de IA são:
  - **Ambiente** - O espaço definido onde o Agente de IA está operando. Por exemplo, se tivermos um Agente de IA para reservas de viagens, o ambiente pode ser o sistema de reservas de viagens que o agente usa para completar tarefas.
  - **Sensores** - Os ambientes possuem informações e fornecem feedback. Agentes de IA usam sensores para coletar e interpretar essas informações sobre o estado atual do ambiente. No exemplo do Agente de Reservas de Viagens, o sistema de reservas pode fornecer informações como disponibilidade de hotéis ou preços de passagens aéreas.
  - **Atuadores** - Depois que o Agente de IA recebe o estado atual do ambiente, ele determina qual ação realizar para alterar o ambiente em relação à tarefa atual. No caso do Agente de Reservas de Viagens, isso pode ser reservar um quarto disponível para o usuário.

![O que são Agentes de IA?](../../../translated_images/what-are-ai-agents.125520f55950b252a429b04a9f41e0152d4dafa1f1bd9081f4f574631acb759e.pt.png?WT.mc_id=academic-105485-koreyst)

**Modelos de Linguagem de Grande Escala (LLMs)** - O conceito de agentes existia antes da criação dos LLMs. A vantagem de construir Agentes de IA com LLMs é sua capacidade de interpretar linguagem humana e dados. Essa habilidade permite que os LLMs interpretem informações do ambiente e definam um plano para alterar o ambiente.

**Executar Ações** - Fora dos sistemas de Agentes de IA, os LLMs são limitados a situações onde a ação é gerar conteúdo ou informações com base em um comando do usuário. Dentro dos sistemas de Agentes de IA, os LLMs podem realizar tarefas interpretando o pedido do usuário e utilizando ferramentas disponíveis no ambiente.

**Acesso a Ferramentas** - As ferramentas às quais o LLM tem acesso são definidas por 1) o ambiente em que está operando e 2) o desenvolvedor do Agente de IA. No exemplo do agente de viagens, as ferramentas do agente são limitadas pelas operações disponíveis no sistema de reservas e/ou o desenvolvedor pode limitar o acesso do agente a ferramentas relacionadas a voos.

**Conhecimento** - Além das informações fornecidas pelo ambiente, os Agentes de IA também podem recuperar conhecimento de outros sistemas, serviços, ferramentas e até outros agentes. No exemplo do agente de viagens, esse conhecimento pode incluir informações sobre as preferências de viagem do usuário localizadas em um banco de dados de clientes.

### Os diferentes tipos de agentes

Agora que temos uma definição geral de Agentes de IA, vamos analisar alguns tipos específicos de agentes e como eles seriam aplicados a um agente de reservas de viagens.

| **Tipo de Agente**            | **Descrição**                                                                                | **Exemplo**                                                                                |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Agentes de Reflexo Simples**| Executam ações imediatas com base em regras predefinidas.                                                                             | O agente de viagens interpreta o contexto de um e-mail e encaminha reclamações de viagem para o atendimento ao cliente.                                                                                |
| **Agentes Baseados em Modelo**| Executam ações com base em um modelo do mundo e mudanças nesse modelo.                                                               | O agente de viagens prioriza rotas com mudanças significativas de preço com base no acesso a dados históricos de preços.                                                                                |
| **Agentes Baseados em Objetivos** | Criam planos para atingir objetivos específicos, interpretando o objetivo e determinando as ações necessárias para alcançá-lo.       | O agente de viagens reserva uma jornada determinando os arranjos de viagem necessários (carro, transporte público, voos) do local atual ao destino.                                                                           |
| **Agentes Baseados em Utilidade** | Consideram preferências e ponderam trade-offs numericamente para determinar como atingir objetivos.                                 | O agente de viagens maximiza a utilidade ao ponderar conveniência versus custo ao reservar viagens.                                                                                |
| **Agentes de Aprendizado**    | Melhoram com o tempo, respondendo a feedbacks e ajustando ações de acordo.                                                           | O agente de viagens melhora usando o feedback de clientes de pesquisas pós-viagem para fazer ajustes em reservas futuras.                                                                                |
| **Agentes Hierárquicos**      | Apresentam múltiplos agentes em um sistema hierárquico, com agentes de nível superior dividindo tarefas em subtarefas para agentes de nível inferior completarem. | O agente de viagens cancela uma viagem dividindo a tarefa em subtarefas (por exemplo, cancelar reservas específicas) e permitindo que agentes de nível inferior as concluam, reportando de volta ao agente de nível superior. |
| **Sistemas Multiagentes (MAS)**| Agentes completam tarefas de forma independente, cooperativa ou competitiva.                                                        | Cooperativo: Múltiplos agentes reservam serviços específicos de viagem, como hotéis, voos e entretenimento. Competitivo: Múltiplos agentes gerenciam e competem por um calendário compartilhado de reservas de hotel.          |

## Quando Usar Agentes de IA

Na seção anterior, usamos o caso de uso do Agente de Viagens para explicar como diferentes tipos de agentes podem ser usados em cenários variados de reservas de viagem. Continuaremos utilizando este exemplo ao longo do curso.

Vamos analisar os tipos de casos de uso que são mais adequados para Agentes de IA:

![Quando usar Agentes de IA?](../../../translated_images/when-to-use-ai-agents.912b9a02e9e0e2af45a3e24faa4e912e334ec23f21f0cf5cb040b7e899b09cd0.pt.png?WT.mc_id=academic-105485-koreyst)

- **Problemas Abertos** - permitindo que o LLM determine os passos necessários para completar uma tarefa, pois nem sempre é possível codificar isso diretamente em um fluxo de trabalho.
- **Processos com Múltiplas Etapas** - tarefas que exigem um nível de complexidade em que o Agente de IA precisa usar ferramentas ou informações ao longo de várias interações, em vez de uma única busca.
- **Melhoria ao Longo do Tempo** - tarefas onde o agente pode melhorar ao longo do tempo ao receber feedback do ambiente ou dos usuários para oferecer melhor utilidade.

Abordamos mais considerações sobre o uso de Agentes de IA na lição Construindo Agentes de IA Confiáveis.

## Fundamentos das Soluções Agênticas

### Desenvolvimento de Agentes

O primeiro passo ao projetar um sistema de Agente de IA é definir as ferramentas, ações e comportamentos. Neste curso, focamos no uso do **Azure AI Agent Service** para definir nossos Agentes. Ele oferece recursos como:

- Seleção de Modelos Abertos, como OpenAI, Mistral e Llama
- Uso de Dados Licenciados por meio de provedores como Tripadvisor
- Uso de ferramentas padronizadas OpenAPI 3.0

### Padrões Agênticos

A comunicação com LLMs é feita por meio de prompts. Dada a natureza semi-autônoma dos Agentes de IA, nem sempre é possível ou necessário reformular manualmente o prompt do LLM após uma mudança no ambiente. Utilizamos **Padrões Agênticos** que permitem que o LLM seja orientado ao longo de várias etapas de maneira mais escalável.

Este curso é dividido em alguns dos padrões agênticos populares atuais.

### Frameworks Agênticos

Frameworks Agênticos permitem que os desenvolvedores implementem padrões agênticos por meio de código. Esses frameworks oferecem templates, plugins e ferramentas para uma melhor colaboração com Agentes de IA. Esses benefícios proporcionam maior observabilidade e resolução de problemas em sistemas de Agentes de IA.

Neste curso, exploraremos o framework AutoGen, baseado em pesquisa, e o framework Agent, pronto para produção, do Semantic Kernel.

**Aviso Legal**:
Este documento foi traduzido utilizando serviços de tradução baseados em IA. Embora nos esforcemos para garantir a precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte oficial. Para informações críticas, recomenda-se uma tradução humana profissional. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.


# Explorar Frameworks de Agentes de IA

Frameworks de agentes de IA são plataformas de software projetadas para simplificar a criação, implantação e gerenciamento de agentes de IA. Esses frameworks fornecem aos desenvolvedores componentes pré-construídos, abstrações e ferramentas que agilizam o desenvolvimento de sistemas complexos de IA.

Eles ajudam os desenvolvedores a se concentrarem nos aspectos únicos de suas aplicações, oferecendo abordagens padronizadas para desafios comuns no desenvolvimento de agentes de IA. Esses frameworks melhoram a escalabilidade, acessibilidade e eficiência na construção de sistemas de IA.

## Introdução

Esta lição abordará:

- O que são frameworks de agentes de IA e o que permitem que os desenvolvedores façam?
- Como as equipes podem usá-los para prototipar rapidamente, iterar e melhorar as capacidades do meu agente?
- Quais são as diferenças entre os frameworks e ferramentas criados pela Microsoft ([Autogen](https://aka.ms/ai-agents/autogen) / [Semantic Kernel](https://aka.ms/ai-agents-beginners/semantic-kernel) / [Azure AI Agent Service](https://aka.ms/ai-agents-beginners/ai-agent-service))?
- Posso integrar diretamente minhas ferramentas existentes do ecossistema Azure ou preciso de soluções independentes?
- O que é o serviço Azure AI Agents e como isso me ajuda?

## Objetivos de aprendizado

Os objetivos desta lição são ajudá-lo a entender:

- O papel dos frameworks de agentes de IA no desenvolvimento de IA.
- Como aproveitar frameworks de agentes de IA para construir agentes inteligentes.
- Capacidades principais habilitadas por frameworks de agentes de IA.
- As diferenças entre Autogen, Semantic Kernel e Azure AI Agent Service.

## O que são frameworks de agentes de IA e o que permitem que os desenvolvedores façam?

Frameworks tradicionais de IA podem ajudar você a integrar IA em seus aplicativos e melhorar esses aplicativos das seguintes maneiras:

- **Personalização**: A IA pode analisar o comportamento e as preferências do usuário para fornecer recomendações, conteúdos e experiências personalizadas.
Exemplo: Serviços de streaming como Netflix usam IA para sugerir filmes e séries com base no histórico de visualização, aumentando o engajamento e a satisfação do usuário.

- **Automação e Eficiência**: A IA pode automatizar tarefas repetitivas, otimizar fluxos de trabalho e melhorar a eficiência operacional.
Exemplo: Aplicativos de atendimento ao cliente usam chatbots com IA para lidar com consultas comuns, reduzindo o tempo de resposta e liberando agentes humanos para questões mais complexas.

- **Melhoria na Experiência do Usuário**: A IA pode aprimorar a experiência geral do usuário, fornecendo recursos inteligentes, como reconhecimento de voz, processamento de linguagem natural e texto preditivo.
Exemplo: Assistentes virtuais como Siri e Google Assistant usam IA para entender e responder a comandos de voz, facilitando a interação dos usuários com seus dispositivos.

### Isso tudo parece ótimo, certo? Então por que precisamos de frameworks de agentes de IA?

Frameworks de agentes de IA representam algo além dos frameworks tradicionais de IA. Eles são projetados para permitir a criação de agentes inteligentes que podem interagir com usuários, outros agentes e o ambiente para alcançar objetivos específicos. Esses agentes podem exibir comportamento autônomo, tomar decisões e se adaptar a condições em constante mudança. Vamos examinar algumas capacidades principais habilitadas pelos frameworks de agentes de IA:

- **Colaboração e Coordenação entre Agentes**: Permitem a criação de múltiplos agentes de IA que podem trabalhar juntos, se comunicar e coordenar para resolver tarefas complexas.
- **Automação e Gerenciamento de Tarefas**: Fornecem mecanismos para automatizar fluxos de trabalho de múltiplas etapas, delegação de tarefas e gerenciamento dinâmico de tarefas entre agentes.
- **Compreensão Contextual e Adaptação**: Equipam os agentes com a capacidade de entender o contexto, se adaptar a ambientes em mudança e tomar decisões com base em informações em tempo real.

Em resumo, os agentes permitem que você faça mais, leve a automação para o próximo nível e crie sistemas mais inteligentes que podem se adaptar e aprender com seu ambiente.

## Como prototipar rapidamente, iterar e melhorar as capacidades do agente?

Este é um cenário em rápida evolução, mas existem alguns elementos comuns na maioria dos frameworks de agentes de IA que podem ajudar você a prototipar e iterar rapidamente, como componentes modulares, ferramentas colaborativas e aprendizado em tempo real. Vamos explorar esses elementos:

- **Use Componentes Modulares**: Frameworks de IA oferecem componentes pré-construídos, como prompts, analisadores e gerenciamento de memória.
- **Aproveite Ferramentas Colaborativas**: Projete agentes com papéis e tarefas específicas, permitindo testar e refinar fluxos de trabalho colaborativos.
- **Aprenda em Tempo Real**: Implemente loops de feedback onde os agentes aprendem com interações e ajustam seu comportamento dinamicamente.

### Use Componentes Modulares

Frameworks como LangChain e Microsoft Semantic Kernel oferecem componentes pré-construídos, como prompts, analisadores e gerenciamento de memória.

**Como as equipes podem usá-los**: As equipes podem montar rapidamente esses componentes para criar um protótipo funcional sem começar do zero, permitindo experimentação e iteração rápidas.

**Como funciona na prática**: Você pode usar um analisador pré-construído para extrair informações da entrada do usuário, um módulo de memória para armazenar e recuperar dados e um gerador de prompts para interagir com os usuários, tudo isso sem precisar construir esses componentes do zero.

**Exemplo de código**: Vamos ver um exemplo de como você pode usar um analisador pré-construído para extrair informações da entrada do usuário:

```python
from langchain import Parser

parser = Parser()
user_input = "Book a flight from New York to London on July 15th"

parsed_data = parser.parse(user_input)

print(parsed_data)
# Output: {'origin': 'New York', 'destination': 'London', 'date': 'July 15th'}
```

O que você pode ver neste exemplo é como você pode aproveitar um analisador pré-construído para extrair informações-chave da entrada do usuário, como origem, destino e data de uma solicitação de reserva de voo. Essa abordagem modular permite que você se concentre na lógica de alto nível.

### Aproveite Ferramentas Colaborativas

Frameworks como CrewAI e Microsoft Autogen facilitam a criação de múltiplos agentes que podem trabalhar juntos.

**Como as equipes podem usá-los**: As equipes podem projetar agentes com funções e tarefas específicas, permitindo testar e refinar fluxos de trabalho colaborativos e melhorar a eficiência geral do sistema.

**Como funciona na prática**: Você pode criar uma equipe de agentes onde cada agente tem uma função especializada, como recuperação de dados, análise ou tomada de decisão. Esses agentes podem se comunicar e compartilhar informações para alcançar um objetivo comum, como responder a uma consulta do usuário ou concluir uma tarefa.

**Exemplo de código (Autogen)**:

```python
# creating agents, then create a round robin schedule where they can work together, in this case in order

# Data Retrieval Agent
# Data Analysis Agent
# Decision Making Agent

agent_retrieve = AssistantAgent(
    name="dataretrieval",
    model_client=model_client,
    tools=[retrieve_tool],
    system_message="Use tools to solve tasks."
)

agent_analyze = AssistantAgent(
    name="dataanalysis",
    model_client=model_client,
    tools=[analyze_tool],
    system_message="Use tools to solve tasks."
)

# conversation ends when user says "APPROVE"
termination = TextMentionTermination("APPROVE")

user_proxy = UserProxyAgent("user_proxy", input_func=input)

team = RoundRobinGroupChat([agent_retrieve, agent_analyze, user_proxy], termination_condition=termination)

stream = team.run_stream(task="Analyze data", max_turns=10)
# Use asyncio.run(...) when running in a script.
await Console(stream)
```

O que você vê no código acima é como você pode criar uma tarefa que envolve múltiplos agentes trabalhando juntos para analisar dados. Cada agente desempenha uma função específica, e a tarefa é executada coordenando os agentes para alcançar o resultado desejado. Criando agentes dedicados com funções especializadas, você pode melhorar a eficiência e o desempenho das tarefas.

### Aprenda em Tempo Real

Frameworks avançados fornecem capacidades para compreensão de contexto em tempo real e adaptação.

**Como as equipes podem usá-los**: As equipes podem implementar loops de feedback onde os agentes aprendem com interações e ajustam seu comportamento dinamicamente, levando a uma melhoria contínua e refinamento das capacidades.

**Como funciona na prática**: Agentes podem analisar o feedback do usuário, dados do ambiente e resultados de tarefas para atualizar sua base de conhecimento, ajustar algoritmos de tomada de decisão e melhorar o desempenho ao longo do tempo. Esse processo de aprendizado iterativo permite que os agentes se adaptem a condições em mudança e preferências dos usuários, melhorando a eficácia geral do sistema.

## Quais são as diferenças entre os frameworks Autogen, Semantic Kernel e Azure AI Agent Service?

Existem várias formas de comparar esses frameworks, mas vamos analisar algumas diferenças principais em termos de design, capacidades e casos de uso:

### Autogen

Framework de código aberto desenvolvido pelo AI Frontiers Lab da Microsoft Research. Focado em aplicações *agênticas* distribuídas e orientadas a eventos, permitindo múltiplos LLMs e SLMs, ferramentas e padrões avançados de design multi-agente.

Autogen é baseado no conceito central de agentes, que são entidades autônomas capazes de perceber seu ambiente, tomar decisões e realizar ações para alcançar objetivos específicos. Os agentes se comunicam por meio de mensagens assíncronas, permitindo que trabalhem de forma independente e em paralelo, melhorando a escalabilidade e a capacidade de resposta do sistema.

Os agentes são baseados no [modelo de ator](https://en.wikipedia.org/wiki/Actor_model). Segundo a Wikipedia, um ator é _a unidade básica de computação concorrente. Em resposta a uma mensagem recebida, um ator pode: tomar decisões locais, criar mais atores, enviar mais mensagens e determinar como responder à próxima mensagem recebida_.

**Casos de Uso**: Automação de geração de código, tarefas de análise de dados e construção de agentes personalizados para funções de planejamento e pesquisa.

...

com base nas metas do projeto. Ideal para compreensão de linguagem natural, geração de conteúdo. - **Azure AI Agent Service**: Modelos flexíveis, mecanismos de segurança empresarial, métodos de armazenamento de dados. Ideal para implantação segura, escalável e flexível de agentes de IA em aplicações empresariais. ## Posso integrar diretamente minhas ferramentas existentes do ecossistema Azure ou preciso de soluções independentes? A resposta é sim, você pode integrar diretamente suas ferramentas existentes do ecossistema Azure com o Azure AI Agent Service, especialmente porque ele foi projetado para funcionar perfeitamente com outros serviços Azure. Você poderia, por exemplo, integrar Bing, Azure AI Search e Azure Functions. Há também uma integração profunda com o Azure AI Foundry. Para Autogen e Semantic Kernel, você também pode integrar com serviços Azure, mas pode ser necessário chamar os serviços Azure a partir do seu código. Outra maneira de integrar é usar os SDKs do Azure para interagir com os serviços Azure a partir dos seus agentes. Além disso, como foi mencionado, você pode usar o Azure AI Agent Service como um orquestrador para seus agentes construídos no Autogen ou Semantic Kernel, o que proporcionaria fácil acesso ao ecossistema Azure. ## Referências - [1] - [Azure Agent Service](https://techcommunity.microsoft.com/blog/azure-ai-services-blog/introducing-azure-ai-agent-service/4298357) - [2] - [Semantic Kernel and Autogen](https://devblogs.microsoft.com/semantic-kernel/microsofts-agentic-ai-frameworks-autogen-and-semantic-kernel/) - [3] - [Semantic Kernel Agent Framework](https://learn.microsoft.com/semantic-kernel/frameworks/agent/?pivots=programming-language-csharp) - [4] - [Azure AI Agent service](https://learn.microsoft.com/azure/ai-services/agents/overview) - [5] - [Using Azure AI Agent Service with AutoGen / Semantic Kernel to build a multi-agent's solution](https://techcommunity.microsoft.com/blog/educatordeveloperblog/using-azure-ai-agent-service-with-autogen--semantic-kernel-to-build-a-multi-agen/4363121)

**Aviso Legal**:
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos para alcançar precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autoritária. Para informações críticas, recomenda-se uma tradução humana profissional. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.