# エージェンティックRAG

このレッスンでは、エージェンティック・リトリーバル・オーグメンテッド・ジェネレーション（Agentic RAG）について包括的に解説します。Agentic RAGは、新たなAIパラダイムで、大規模言語モデル（LLM）が外部ソースから情報を取得しながら、自律的に次のステップを計画する仕組みです。従来の静的な「検索してから読む」パターンとは異なり、Agentic RAGでは、ツールや関数の呼び出し、構造化された出力を交えた反復的なLLM呼び出しが行われます。システムは結果を評価し、クエリを洗練し、必要に応じて追加のツールを呼び出し、満足のいく解決策が得られるまでこのサイクルを続けます。

## はじめに

このレッスンでは以下を学びます：

- **エージェンティックRAGを理解する:** 大規模言語モデル（LLM）が外部データソースから情報を取得しながら、自律的に次のステップを計画する新しいAIパラダイムについて学ぶ
- **反復的な「メーカー・チェッカー」スタイルを把握する:** ツールや関数呼び出し、構造化された出力を交えた反復的なLLM呼び出しのループを理解し、正確性の向上や不完全なクエリの処理方法を学ぶ
- **実用的な応用例を探る:** 正確性が最優先される環境、複雑なデータベースの操作、長時間のワークフローなど、Agentic RAGが活躍するシナリオを特定する

## 学習目標

このレッスンを修了すると、以下を理解し、実践できるようになります：

- **エージェンティックRAGの理解:** 大規模言語モデル（LLM）が外部データソースから情報を取得しながら、自律的に次のステップを計画する新しいAIパラダイムについて学ぶ
- **反復的な「メーカー・チェッカー」スタイル:** ツールや関数呼び出し、構造化された出力を交えた反復的なLLM呼び出しのループを把握し、不完全なクエリの処理や正確性の向上を目指す
- **推論プロセスの所有:** 問題へのアプローチを事前定義されたパスに頼らず、自律的に決定するシステムの能力を理解する
- **ワークフロー:** エージェンティックモデルが市場動向レポートを取得し、競合他社のデータを特定し、内部販売指標を相関させ、結果を統合し、戦略を評価する流れを理解する
- **反復ループ、ツール統合、メモリ:** システムが反復的なインタラクションパターンに依存し、ステップ間で状態とメモリを維持し、繰り返しを避けながら情報に基づいた意思決定を行う方法を学ぶ
- **失敗モードの処理と自己修正:** クエリの再試行や診断ツールの使用、人間の監視に頼るなど、システムの強力な自己修正メカニズムを探る
- **エージェンシーの限界:** ドメイン固有の自律性、インフラストラクチャへの依存、ガードレールの尊重に焦点を当て、Agentic RAGの限界を理解する
- **実用的な使用例と価値:** 正確性が重要な環境、複雑なデータベース操作、長時間のワークフローなど、Agentic RAGが活躍するシナリオを特定する
- **ガバナンス、透明性、信頼:** 説明可能な推論、バイアス制御、人間による監視の重要性を学ぶ

## Agentic RAGとは？

エージェンティック・リトリーバル・オーグメンテッド・ジェネレーション（Agentic RAG）は、大規模言語モデル（LLM）が外部ソースから情報を取得しながら、自律的に次のステップを計画する新たなAIパラダイムです。従来の静的な「検索してから読む」パターンとは異なり、Agentic RAGでは、ツールや関数呼び出し、構造化された出力を交えた反復的なLLM呼び出しが行われます。システムは結果を評価し、クエリを洗練し、必要に応じて追加のツールを呼び出し、満足のいく解決策が得られるまでこのサイクルを続けます。この反復的な「メーカー・チェッカー」スタイルは、正確性を向上させ、不完全なクエリを処理し、高品質な結果を保証します。

システムは推論プロセスを積極的に管理し、失敗したクエリを書き直し、異なる検索方法を選択し、複数のツール（Azure AI Searchのベクター検索、SQLデータベース、カスタムAPIなど）を統合して最終的な回答を完成させます。エージェンティックシステムの際立った特徴は、推論プロセスを自ら管理できる点です。従来のRAG実装では事前定義されたパスに依存しますが、エージェンティックシステムは、見つかった情報の質に基づいて次のステップの順序を自律的に決定します。

## エージェンティック・リトリーバル・オーグメンテッド・ジェネレーション（Agentic RAG）の定義

エージェンティック・リトリーバル・オーグメンテッド・ジェネレーション（Agentic RAG）は、LLMが外部データソースから情報を取得するだけでなく、自律的に次のステップを計画するAI開発の新しいパラダイムです。従来の静的な「検索してから読む」パターンや慎重にスクリプト化されたプロンプトシーケンスとは異なり、Agentic RAGは、ツールや関数呼び出し、構造化された出力を交えた反復的なLLM呼び出しのループを含みます。各ステップで、システムは得られた結果を評価し、クエリを洗練するかどうかを決定し、必要に応じて追加のツールを呼び出し、満足のいく解決策が得られるまでこのサイクルを続けます。

この反復的な「メーカー・チェッカー」スタイルの操作は、正確性を向上させ、構造化データベース（例：NL2SQL）に対する不完全なクエリを処理し、バランスの取れた高品質な結果を保証するよう設計されています。慎重に設計されたプロンプトチェーンにのみ依存するのではなく、システムは推論プロセスを積極的に管理します。失敗したクエリを書き直し、異なる検索方法を選択し、複数のツール（Azure AI Searchのベクター検索、SQLデータベース、カスタムAPIなど）を統合して最終的な回答を完成させます。これにより、複雑なオーケストレーションフレームワークの必要性がなくなります。代わりに、「LLM呼び出し → ツール使用 → LLM呼び出し → …」という比較的シンプルなループで洗練された、根拠のある出力を得ることができます。

![Agentic RAG Core Loop](../../../translated_images/agentic-rag-core-loop.2224925a913fb3439f518bda61a40096ddf6aa432a11c9b5bba8d0d625e47b79.ja.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.ja.png)

エージェンティックシステムは、ループ型のインタラクションパターンに依存しています：

- **初回呼び出し:** ユーザーの目的（ユーザープロンプト）がLLMに提示されます。
- **ツールの呼び出し:** モデルが不足している情報や曖昧な指示を特定した場合、ベクターデータベースクエリ（例：Azure AI Searchによるプライベートデータのハイブリッド検索）や構造化されたSQL呼び出しなど、ツールや検索方法を選択してさらなるコンテキストを収集します。
- **評価と洗練:** 返されたデータをレビューした後、モデルは情報が十分かどうかを判断します。不十分であれば、クエリを洗練し、別のツールを試すか、アプローチを調整します。
- **満足するまで繰り返す:** このサイクルは、モデルが十分な明確さと証拠を得て、最終的な合理的な回答を提供できると判断するまで続きます。
- **メモリと状態:** システムはステップ間で状態とメモリを維持するため、以前の試みとその結果を記憶し、繰り返しを避け、進行する中でより情報に基づいた意思決定を行います。

時間が経つにつれて、これにより進化する理解が生まれ、モデルは複雑なマルチステップタスクを人間が介入したりプロンプトを再形成したりする必要なく、効率的に処理することが可能になります。

## 失敗モードの処理と自己修正

エージェンティックRAGの自律性には、強力な自己修正メカニズムも含まれています。システムが行き詰まった場合（例：無関係なドキュメントを取得したり、不完全なクエリに遭遇したりした場合）、以下のアプローチを取ります：

- **反復と再クエリ:** 低価値の回答を返す代わりに、モデルは新しい検索戦略を試みたり、データベースクエリを書き直したり、代替データセットを調べたりします。
- **診断ツールの使用:** システムは、推論ステップをデバッグしたり、取得したデータの正確性を確認するための追加機能を呼び出す場合があります。Azure AI Tracingなどのツールは、堅牢な観測性と監視を可能にする重要な要素です。
- **人間の監視に頼る:** 高リスクまたは繰り返し失敗するシナリオでは、モデルは不確実性をフラグとして示し、人間の指導を求める場合があります。人間が修正フィードバックを提供した後、モデルはそのレッスンを今後のセッションに反映させることができます。

この反復的かつ動的なアプローチにより、モデルは継続的に改善し、単なる一度限りのシステムではなく、セッション中に失敗から学ぶことができるシステムとなります。

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

## エージェンシーの限界

タスク内での自律性がある一方で、エージェンティックRAGは人工汎用知能（AGI）と同義ではありません。その「エージェンティック」な能力は、人間の開発者が提供したツール、データソース、ポリシーに制限されています。独自のツールを発明したり、設定されたドメインの境界を超えたりすることはできません。その代わり、手元のリソースを動的にオーケストレーションすることに長けています。

より高度なAI形式との主な違いは以下の通りです：

1. **ドメイン固有の自律性:** エージェンティックRAGシステムは、ユーザー定義の目標を達成することに焦点を当てており、クエリの書き換えやツールの選択などの戦略を用いて結果を向上させます。
2. **インフラストラクチャ依存:** システムの能力は、開発者によって統合されたツールとデータに依存しています。これらの境界を人間の介入なしに超えることはできません。
3. **ガードレールの尊重:** 倫理的ガイドライン、コンプライアンスルール、ビジネスポリシーは依然として非常に重要です。エージェントの自由度は常に安全対策と監視メカニズムによって制約されています（おそらく？）。

## 実用的な使用例と価値

エージェンティックRAGは、反復的な洗練と精度が求められるシナリオで活躍します：

1. **正確性が最優先される環境:** コンプライアンスチェック、規制分析、法的調査などでは、エージェンティックモデルが繰り返し事実を確認し、複数のソースを参照し、クエリを書き直して、徹底的に検証された回答を提供します。
2. **複雑なデータベース操作:** クエリが頻繁に失敗したり調整が必要となる構造化データを扱う際、Azure SQLやMicrosoft Fabric OneLakeを使用してクエリを自律的に洗練し、最終的な取得がユーザーの意図に一致するようにします。
3. **長時間のワークフロー:** 新しい情報が出てくるにつれて進化するセッションでは、エージェンティックRAGが継続的に新しいデータを取り込み、問題領域について学びながら戦略を変更します。

## ガバナンス、透明性、信頼

これらのシステムが推論においてより自律的になるにつれ、ガバナンスと透明性が重要になります：

- **説明可能な推論:** モデルは、作成したクエリ、参照したソース、結論に至るまでの推論ステップの監査トレイルを提供できます。Azure AI Content SafetyやAzure AI Tracing / GenAIOpsのようなツールは、透明性を維持し、リスクを軽減するのに役立ちます。
- **バイアス制御とバランスの取れた検索:** 開発者は、バランスの取れた代表的なデータソースが考慮されるように検索戦略を調整し、Azure Machine Learningを使用して出力を定期的に監査し、バイアスや偏ったパターンを検出します。
- **人間の監視とコンプライアンス:** 敏感なタスクでは、人間によるレビューが依然として不可欠です。エージェンティックRAGは、高リスクの意思決定において人間の判断を置き換えるものではなく、より徹底的に検証された選択肢を提供することでそれを補完します。

マルチステップ

**免責事項**:
この文書は、機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期すよう努めておりますが、自動翻訳には誤りや不正確さが含まれる可能性があります。元の言語で作成された原文が正式な情報源とみなされるべきです。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用に起因する誤解や誤った解釈について、当社は一切の責任を負いません。


# 信頼できるAIエージェントの構築

## はじめに

このレッスンでは以下について学びます：

- 安全で効果的なAIエージェントの構築とデプロイ方法
- AIエージェント開発時の重要なセキュリティ考慮点
- データとユーザーのプライバシーを保護しながらAIエージェントを開発する方法

## 学習目標

このレッスンを完了すると、次のことができるようになります：

- AIエージェントを作成する際のリスクを特定し、軽減する方法を理解する。
- データとアクセスが適切に管理されるようにセキュリティ対策を実装する。
- データプライバシーを保ち、質の高いユーザー体験を提供するAIエージェントを作成する。

## 安全性

まず、安全なエージェントアプリケーションの構築について考えてみましょう。安全性とは、AIエージェントが設計通りに動作することを意味します。エージェントアプリケーションの開発者として、安全性を最大化するための方法とツールを活用することができます。

### メタプロンプトシステムの構築

もし大規模言語モデル（LLM）を使用してAIアプリケーションを構築したことがあるなら、堅牢なシステムプロンプトやシステムメッセージを設計する重要性をご存じでしょう。これらのプロンプトは、LLMがユーザーやデータとどのようにやり取りするかのメタルールや指示、ガイドラインを設定します。

AIエージェントの場合、システムプロンプトはさらに重要です。なぜなら、エージェントが設計されたタスクを完了するためには、非常に具体的な指示が必要だからです。

スケーラブルなシステムプロンプトを作成するために、アプリケーション内で1つ以上のエージェントを構築する際にメタプロンプトシステムを活用できます。

![メタプロンプトシステムの構築](../../../translated_images/building-a-metaprompting-system.aa7d6de2100b0ef48c3e1926dab6903026b22fc9d27fc4327162fbbb9caf960f.ja.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エージェントに対するさまざまな脅威の一部と、それに対してどのように計画し準備できるかを見ていきます。

![脅威の理解](../../../translated_images/understanding-threats.f8fbe6fe11e025b3085fc91e82d975937ad1d672260a2aeed40458aa41798d0e.ja.png)

### タスクと指示

**説明:** 攻撃者がプロンプトや入力を操作することで、AIエージェントの指示や目標を変更しようとします。

**軽減策:** 危険なプロンプトをAIエージェントが処理する前に検出するためのバリデーションチェックや入力フィルターを実行します。これらの攻撃は通常、エージェントとの頻繁なやり取りを必要とするため、会話のターン数を制限することも防止策の一つです。

### 重要なシステムへのアクセス

**説明:** AIエージェントが機密データを保存するシステムやサービスにアクセスできる場合、攻撃者はこれらのサービスとの通信を侵害する可能性があります。これには、直接的な攻撃やエージェントを介してこれらのシステムに関する情報を得ようとする間接的な試みが含まれます。

**軽減策:** この種の攻撃を防ぐために、AIエージェントは必要最小限のアクセス権のみを持つべきです。エージェントとシステム間の通信も安全にする必要があります。認証とアクセス制御を実装することも、この情報を保護する方法の一つです。

### リソースとサービスの過負荷

**説明:** AIエージェントはタスクを完了するためにさまざまなツールやサービスにアクセスします。攻撃者はこの能力を利用して、AIエージェントを介して大量のリクエストを送信し、システム障害や高額なコストを引き起こす可能性があります。

**軽減策:** AIエージェントがサービスに送信できるリクエストの数を制限するポリシーを実装します。AIエージェントとの会話のターン数やリクエスト数を制限することも、この種の攻撃を防ぐ方法です。

### 知識ベースの汚染

**説明:** この種の攻撃はAIエージェントそのものを直接狙うのではなく、エージェントが使用する知識ベースやその他のサービスを標的とします。これには、エージェントがタスクを完了するために使用するデータや情報を改ざんし、偏ったり意図しない応答をユーザーに返すようにすることが含まれます。

**軽減策:** AIエージェントがワークフローで使用するデータを定期的に検証します。このデータへのアクセスを安全に保ち、信頼できる人物のみが変更できるようにすることで、この種の攻撃を防ぎます。

### エラーの連鎖

**説明:** AIエージェントはタスクを完了するためにさまざまなツールやサービスにアクセスします。攻撃者によって引き起こされたエラーが、エージェントが接続している他のシステムの障害につながり、攻撃が広範囲に広がり、トラブルシューティングが困難になる可能性があります。

**軽減策:** この問題を回避する一つの方法は、AIエージェントがDockerコンテナ内でタスクを実行するなど、制限された環境で動作するようにすることです。特定のシステムがエラーを返した場合に備えたフォールバックメカニズムやリトライロジックを作成することも、大規模なシステム障害を防ぐ方法です。

## ヒューマン・イン・ザ・ループ

信頼できるAIエージェントシステムを構築するもう一つの効果的な方法は、ヒューマン・イン・ザ・ループを活用することです。これにより、ユーザーがエージェントの実行中にフィードバックを提供できるフローが作られます。ユーザーは、マルチエージェントシステム内のエージェントとして機能し、実行中のプロセスを承認または終了させる役割を果たします。

![ヒューマン・イン・ザ・ループ](../../../translated_images/human-in-the-loop.e9edbe8f6d42041b4213421410823250aa750fe8bdba5601d69ed46f3ff6489d.ja.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.ja.png)

多くの現実世界のタスクは、単一ステップで取り組むには複雑すぎます。AIエージェントには、計画と行動を導くための簡潔な目標が必要です。例えば、以下の目標を考えてみましょう：

    "3日間の旅行プランを作成する。"

この目標は一見シンプルですが、さらに具体化が必要です。目標が明確であればあるほど、エージェント（および人間の協力者）は、適切な結果を達成することに集中できます。例えば、フライトオプション、ホテルのおすすめ、アクティビティの提案を含む包括的な旅程を作成することが求められる場合です。

### タスクの分解

大規模または複雑なタスクは、小さく目標志向のサブタスクに分割することで扱いやすくなります。
旅行プランの例では、次のように目標を分解できます：

* フライト予約
* ホテル予約
* レンタカー手配
* パーソナライズ

各サブタスクは、専用のエージェントやプロセスによって処理されます。例えば、フライトの最適な料金を検索するエージェント、ホテル予約に特化したエージェントなどです。その後、調整役または「下流」のエージェントが、これらの結果をまとめてユーザーに一つの統合された旅程として提供します。

このモジュール式アプローチは、段階的な改善も可能にします。例えば、フードのおすすめや地元のアクティビティの提案に特化したエージェントを追加し、旅程をさらに洗練させることができます。

### 構造化された出力

大規模言語モデル（LLM）は、JSONのような構造化された出力を生成できます。これにより、下流のエージェントやサービスが解析・処理しやすくなります。これは特にマルチエージェント環境において有用で、計画出力を受け取った後にタスクを実行できます。この点については、[こちらのブログ記事](https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/cookbook/structured-output-agent.html)をご参照ください。

以下は、計画エージェントが目標をサブタスクに分解し、構造化された計画を生成する簡単なPythonコードの例です：

### マルチエージェントオーケストレーションを活用した計画エージェント

この例では、Semantic Router Agentがユーザーのリクエスト（例："旅行のためのホテルプランが必要です。"）を受け取ります。

計画エージェントは以下の手順を実行します：

* **ホテルプランの受信**: エージェントはユーザーのメッセージを受け取り、システムプロンプト（利用可能なエージェントの詳細を含む）に基づいて構造化された旅行プランを生成します。
* **エージェントとそのツールの一覧化**: エージェントレジストリには、フライト、ホテル、レンタカー、アクティビティなどのエージェントリストと、それぞれが提供する機能やツールが含まれています。
* **プランの割り当て**: サブタスクの数に応じて、計画エージェントは専用エージェントに直接メッセージを送信する（単一タスクの場合）か、グループチャットマネージャーを介してマルチエージェントでのコラボレーションを調整します。
* **結果の要約**: 最後に、生成されたプランを要約して分かりやすくします。

以下はこれらのステップを示す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サービスを使用して翻訳されています。正確性を追求しておりますが、自動翻訳にはエラーや不正確さが含まれる可能性があることをご了承ください。原文（元の言語の文書）が公式な情報源と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。本翻訳の使用に起因する誤解や解釈の誤りについて、当方は一切の責任を負いません。


# マルチエージェント設計パターン

複数のエージェントを含むプロジェクトに取り組み始めると、マルチエージェント設計パターンを考慮する必要があります。ただし、いつマルチエージェントに切り替えるべきか、その利点が何であるかはすぐには明確にならないかもしれません。

## はじめに

このレッスンでは、以下の質問に答えることを目指します：

- マルチエージェントが適用されるシナリオはどのようなものか？
- 単一のエージェントが複数のタスクを行う場合と比べて、マルチエージェントを使用する利点は何か？
- マルチエージェント設計パターンを実装するための構成要素は何か？
- 複数のエージェントがどのように相互作用しているかをどのように可視化するか？

## 学習目標

このレッスンの後、次のことができるようになります：

- マルチエージェントが適用されるシナリオを特定する。
- 単一エージェントよりもマルチエージェントを使用する利点を理解する。
- マルチエージェント設計パターンを実装するための構成要素を理解する。

全体像は？

*マルチエージェントは、複数のエージェントが協力して共通の目標を達成するための設計パターン*です。

このパターンは、ロボティクス、自律システム、分散コンピューティングなど、さまざまな分野で広く使用されています。

## マルチエージェントが適用されるシナリオ

では、どのようなシナリオがマルチエージェントの使用に適しているでしょうか？答えは、多くのシナリオで複数のエージェントを使用することが有益であり、特に以下の場合に効果的です：

- **大規模な作業負荷**: 大規模な作業負荷は小さなタスクに分割され、それぞれ異なるエージェントに割り当てることで、並列処理と迅速な完了が可能になります。例としては、大量のデータ処理タスクがあります。
- **複雑なタスク**: 複雑なタスクも、小さなサブタスクに分割され、それぞれ特定の側面に特化したエージェントに割り当てられます。例としては、自動運転車があり、異なるエージェントがナビゲーション、障害物検知、他の車両との通信を管理します。
- **多様な専門性**: 異なるエージェントが多様な専門性を持つことで、単一エージェントよりもタスクの異なる側面を効果的に処理できます。例としては、医療分野で診断、治療計画、患者モニタリングを管理するエージェントが挙げられます。

## 単一エージェントよりマルチエージェントを使用する利点

単一エージェントシステムは単純なタスクには適していますが、より複雑なタスクでは、複数のエージェントを使用することでいくつかの利点が得られます：

- **専門化**: 各エージェントが特定のタスクに特化できます。単一エージェントの専門性の欠如は、複雑なタスクに直面した際に混乱を招き、適切でないタスクに取り組む可能性があります。
- **スケーラビリティ**: 単一エージェントを過負荷にするのではなく、エージェントを追加することでシステムを拡張する方が簡単です。
- **フォールトトレランス**: 1つのエージェントが失敗しても、他のエージェントが機能を続行することで、システムの信頼性が確保されます。

例を挙げてみましょう。ユーザーの旅行を予約するシステムを考えます。単一エージェントシステムでは、フライト検索からホテル予約、レンタカーの手配まで、旅行予約プロセスのすべての側面を処理する必要があります。このようなシステムを単一エージェントで実現するには、すべてのタスクを処理するためのツールが必要になり、維持や拡張が困難な複雑でモノリシックなシステムになる可能性があります。一方、マルチエージェントシステムでは、フライト検索、ホテル予約、レンタカー手配に特化した異なるエージェントを持つことができます。このようなシステムは、よりモジュール化され、維持が容易で、スケーラブルになります。

これは、個人経営の旅行代理店とフランチャイズ型の旅行代理店を比較するようなものです。個人経営の代理店では、単一のエージェントがすべての旅行予約プロセスを処理しますが、フランチャイズでは、各エージェントが異なる側面を処理します。

## マルチエージェント設計パターンを実装するための構成要素

マルチエージェント設計パターンを実装する前に、このパターンを構成する要素を理解する必要があります。

ユーザーの旅行を予約する例をもう一度考えてみましょう。この場合、構成要素には以下が含まれます：

- **エージェント間の通信**: フライト検索、ホテル予約、レンタカー手配のエージェントが、ユーザーの希望や制約について情報を共有する必要があります。この通信のプロトコルや方法を決定する必要があります。具体的には、フライト検索エージェントがホテル予約エージェントと連携し、フライトの日程に合わせてホテルを予約する必要があります。つまり、*どのエージェントが情報を共有し、どのように共有するのか*を決める必要があります。
- **調整メカニズム**: エージェントがユーザーの希望や制約を満たすために行動を調整する必要があります。たとえば、ユーザーが空港近くのホテルを希望する場合や、レンタカーが空港でのみ利用可能な場合、ホテル予約エージェントとレンタカー手配エージェントが調整する必要があります。つまり、*エージェントがどのように行動を調整するのか*を決める必要があります。
- **エージェントアーキテクチャ**: エージェントは意思決定を行い、ユーザーとのやり取りから学習するための内部構造を持つ必要があります。たとえば、フライト検索エージェントは、ユーザーに推奨するフライトを決定するための内部構造を持つ必要があります。これには、過去の好みに基づいてフライトを推奨する機械学習モデルを使用することが含まれます。
- **マルチエージェント間の相互作用の可視性**: 複数のエージェントがどのように相互作用しているかを可視化する必要があります。これには、エージェントの活動や相互作用を追跡するためのツールや技術が必要です。これには、ログやモニタリングツール、可視化ツール、パフォーマンス指標が含まれる可能性があります。
- **マルチエージェントパターン**: マルチエージェントシステムを実装するためのパターンには、集中型、分散型、ハイブリッド型のアーキテクチャがあります。ユースケースに最適なパターンを選択する必要があります。
- **人間の介入**: 多くの場合、人間が介入する場面があり、エージェントにいつ人間の判断を求めるべきかを指示する必要があります。たとえば、エージェントが推奨しなかった特定のホテルやフライトをユーザーが希望する場合や、予約前に確認を求める場合などです。

## マルチエージェント間の相互作用の可視性

複数のエージェントがどのように相互作用しているかを可視化することは重要です。この可視性は、デバッグ、最適化、全体的なシステムの効果を確保するために不可欠です。これを実現するには、エージェントの活動や相互作用を追跡するためのツールや技術が必要です。たとえば、ユーザーの旅行を予約する場合、各エージェントのステータス、ユーザーの希望や制約、エージェント間の相互作用を表示するダッシュボードを作成することができます。

各要素をもう少し詳しく見てみましょう。

- **ログとモニタリングツール**: 各エージェントが取ったアクションごとにログを記録します。ログには、アクションを取ったエージェント、取ったアクション、アクションが取られた時間、アクションの結果に関する情報を記録できます。この情報は、デバッグや最適化などに使用できます。
- **可視化ツール**: 可視化ツールを使用すると、エージェント間の相互作用をより直感的に把握できます。たとえば、エージェント間の情報の流れを示すグラフを作成することができます。これにより、ボトルネックや非効率性、その他の問題を特定できます。
- **パフォーマンス指標**: パフォーマンス指標を使用して、マルチエージェントシステムの効果を追跡できます。たとえば、タスクの完了にかかった時間、単位時間あたりに完了したタスク数、エージェントが行った推奨の正確性などを追跡できます。この情報を使用して、改善点を特定し、システムを最適化できます。

## マルチエージェントパターン

マルチエージェントアプリを作成するために使用できる具体的なパターンについて見ていきましょう。以下は、検討に値する興味深いパターンです：

### グループチャット

このパターンは、複数のエージェントが相互にコミュニケーションできるグループチャットアプリケーションを作成したい場合に役立ちます。典型的なユースケースには、チームコラボレーション、カスタマーサポート、ソーシャルネットワーキングが含まれます。

このパターンでは、各エージェントがグループチャット内のユーザーを表し、メッセージプロトコルを使用してメッセージがエージェント間で交換されます。エージェントはグループチャットにメッセージを送信し、グループチャットからメッセージを受信し、他のエージェントからのメッセージに応答できます。

このパターンは、すべてのメッセージが中央サーバーを介してルーティングされる集中型アーキテクチャ、またはメッセージが直接交換される分散型アーキテクチャを使用して実装できます。

![Group chat](../../../translated_images/multi-agent-group-chat.82d537c5c8dc833abbd252033e60874bc9d00df7193888b3377f8426449a0b20.ja.png)

### ハンドオフ

このパターンは、複数のエージェントがタスクを互いに引き継ぐアプリケーションを作成したい場合に役立ちます。

典型的なユースケースには、カスタマーサポート、タスク管理、ワークフロー自動化が含まれます。

このパターンでは、各エージェントがタスクまたはワークフロー内のステップを表し、事前定義されたルールに基づいてエージェント間でタスクを引き継ぐことができます。

![Hand off](../../../translated_images/multi-agent-hand-off.ed4f0a5a58614a8a3e962fc476187e630a3ba309d066e460f017b503d0b84cfc.ja.png)

### 協調フィルタリング

このパターンは、複数のエージェントが協力してユーザーに推奨を行うアプリケーションを作成したい場合に役立ちます。

複数のエージェントが協力する理由は、各エージェントが異なる専門知識を持ち、推奨プロセスに異なる形で貢献できるためです。

たとえば、ユーザーが株式市場で購入するのに最適な株を推奨してほしい場合を考えてみましょう。

- **業界の専門家**: 1つのエージェントは特定の業界に精通している。
- **テクニカル分析**: 別のエージェントはテクニカル分析の専門家である。
- **ファンダメンタル分析**: さらに別のエージェントはファンダメンタル分析の専門家である。これらのエージェントが協力することで、ユーザーに対してより包括的な推奨を提供できます。

![Recommendation](../../../translated_images/multi-agent-filtering.719217d169391ddb118bbb726b19d4d89ee139f960f8749ccb2400efb4d0ce79.ja.png)

## シナリオ: 返金プロセス

顧客が商品の返金を求めるシナリオを考えてみましょう。このプロセスには多くのエージェントが関与する可能性がありますが、このプロセスに特化したエージェントと、他のプロセスでも使用できる汎用エージェントに分けて考えます。

**返金プロセスに特化したエージェント**:

以下は、返金プロセスに関与する可能性のあるエージェントです：

- **顧客エージェント**: 顧客を表し、返金プロセスを開始する役割を担います。
- **販売者エージェント**: 販売者を表し、返金処理を担当します。
- **支払いエージェント**: 支払いプロセスを表し、顧客への支払い返金を担当します。
- **解決エージェント**: 解決プロセスを表し、返金プロセス中に発生する問題を解決します。
- **コンプライアンスエージェント**: コンプライアンスプロセスを表し、返金プロセスが規制やポリシーに準拠していることを確認します。

**汎用エージェント**:

これらのエージェントは、ビジネスの他の部分でも使用できます。

- **配送エージェント**: 配送プロセスを表し、商品を販売者に返送する役割を担います。このエージェントは、返金プロセスだけでなく、購入時の一般的な配送にも使用できます。
- **フィードバックエージェント**: フィードバックプロセスを表し、顧客からフィードバックを収集します。フィードバックは、返金プロセスだけでなく、いつでも収集できます。
- **エスカレーションエージェント**: エスカレーションプロセスを表し、問題を上位サポートレベルにエスカレートする役割を担います。このタイプのエージェントは、エスカレーションが必要なあらゆるプロセスで使用できます。
- **通知エージェント**: 通知プロセスを表し、返金プロセスのさまざまな段階で顧客に通知を送信します。
- **分析エージェント**: 分析プロセスを表し、返金プロセスに関連するデータを分析します。
- **監査エージェント**: 監査プロセスを表し、返金プロセスが正しく実行されていることを確認します。
- **レポートエージェント**: レポートプロセスを表し、返金プロセスに関するレポートを生成します。
- **ナレッジエージェント**: ナレッジプロセスを表し、返金プロセスに関連する情報のナレッジベースを維持します。このエージェントは、返金に関する知識だけでなく、ビジネスの他の部分についても知識を持つことができます。
- **セキュリティエージェント**: セキュリティプロセスを表し、返金プロセスのセキュリティを確保します。
- **品質エージェント**: 品質プロセスを表し、返金プロセスの品質を確保します。

上記には、特定の返金プロセス用のエージェントと、ビジネスの他の

**免責事項**:
本書類は、機械翻訳AIサービスを使用して翻訳されています。正確性を期して努力しておりますが、自動翻訳にはエラーや不正確な表現が含まれる可能性があります。元の言語で作成された原本を正式な情報源としてご参照ください。重要な情報については、専門の人間による翻訳をお勧めします。本翻訳の利用に起因する誤解や誤った解釈について、当社は一切の責任を負いかねます。


# AIエージェントにおけるメタ認知

## はじめに

AIエージェントにおけるメタ認知に関するレッスンへようこそ！この章は、AIエージェントが自分自身の思考プロセスをどのように考えることができるかに興味を持つ初心者向けに設計されています。このレッスンを終える頃には、重要な概念を理解し、AIエージェントの設計にメタ認知を応用するための実践的な例を身につけることができるでしょう。

## 学習目標

このレッスンを完了すると、以下ができるようになります：

1. エージェントの定義における推論ループの影響を理解する。
2. 自己修正型エージェントを支援する計画および評価技術を使用する。
3. タスクを達成するためにコードを操作できるエージェントを作成する。

## メタ認知の紹介

メタ認知とは、自分自身の思考について考えるという高次の認知プロセスを指します。AIエージェントの場合、これは自己認識や過去の経験に基づいて行動を評価し、調整する能力を意味します。

### メタ認知とは？

メタ認知、つまり「思考についての思考」は、自己認識や自分の認知プロセスの自己調整を伴う高次の認知プロセスです。AIの分野では、メタ認知によりエージェントが戦略や行動を評価し適応させることができ、問題解決能力や意思決定能力の向上につながります。メタ認知を理解することで、より知的で適応性が高く効率的なAIエージェントを設計することができます。

### AIエージェントにおけるメタ認知の重要性

メタ認知は、AIエージェント設計において以下の理由から重要な役割を果たします：

![メタ認知の重要性](../../../translated_images/importance-of-metacognition.e351a5983bb745d60a1a60185391a39a6751d033c8c1948ceb6ad04eff7dbeac.ja.png)

- **自己反省**：エージェントは自分のパフォーマンスを評価し、改善が必要な領域を特定できます。
- **適応性**：エージェントは過去の経験や変化する環境に基づいて戦略を修正できます。
- **エラー修正**：エージェントはエラーを自律的に検出し修正することで、より正確な結果をもたらします。
- **リソース管理**：エージェントは、時間や計算能力などのリソースを計画し評価することで最適化できます。

## AIエージェントの構成要素

メタ認知プロセスに入る前に、AIエージェントの基本的な構成要素を理解することが重要です。AIエージェントは通常、以下の要素で構成されています：

- **ペルソナ**：エージェントの個性や特徴を指し、ユーザーとのやり取りの仕方を定義します。
- **ツール**：エージェントが実行できる能力や機能。
- **スキル**：エージェントが持つ知識や専門性。

これらの要素が組み合わさり、特定のタスクを実行する「専門ユニット」を形成します。

**例**：旅行代理店を考えてみましょう。このエージェントは、ユーザーの旅行を計画するだけでなく、リアルタイムデータや過去の顧客経験に基づいてその計画を調整します。

### 例：旅行代理店サービスにおけるメタ認知

AIを活用した旅行代理店サービスを設計する場面を想像してみてください。このエージェント「Travel Agent」は、ユーザーの休暇計画を支援します。メタ認知を取り入れることで、Travel Agentは自己認識や過去の経験に基づいて行動を評価し調整することができます。

#### 現在のタスク

現在のタスクは、ユーザーがパリ旅行を計画するのを支援することです。

#### タスクを完了するためのステップ

1. **ユーザーの好みを収集**：旅行日程、予算、興味（例：博物館、料理、ショッピング）、特定の要件についてユーザーに尋ねます。
2. **情報の取得**：ユーザーの好みに合ったフライトオプション、宿泊施設、観光地、レストランを検索します。
3. **提案の生成**：フライト詳細、ホテル予約、提案されたアクティビティを含む個別の旅程を提供します。
4. **フィードバックに基づく調整**：提案に対するユーザーのフィードバックを求め、必要に応じて調整を行います。

#### 必要なリソース

- フライトおよびホテル予約データベースへのアクセス。
- パリの観光地やレストランに関する情報。
- 過去のインタラクションからのユーザーフィードバックデータ。

#### 経験と自己反省

Travel Agentは、パフォーマンスを評価し、過去の経験から学ぶためにメタ認知を使用します。

1. **ユーザーフィードバックの分析**：提案が好評だったものとそうでなかったものを確認し、将来の提案を調整します。
2. **適応性**：例えば、ユーザーが以前に混雑した場所を嫌うと述べた場合、Travel Agentは今後ピーク時間帯の観光地を避けるようにします。
3. **エラー修正**：過去に満室のホテルを提案するなどのエラーがあった場合、より厳密に空室状況を確認することを学びます。

#### 実践的な開発者向け例

以下は、メタ認知を取り入れたTravel Agentのコードがどのように見えるかの簡単な例です：

```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)
```

#### メタ認知が重要な理由

- **自己反省**：エージェントはパフォーマンスを分析し、改善が必要な領域を特定できます。
- **適応性**：フィードバックや変化する条件に基づいて戦略を修正できます。
- **エラー修正**：エージェントは自律的にエラーを検出し修正できます。
- **リソース管理**：時間や計算能力などのリソースを最適化できます。

メタ認知を取り入れることで、Travel Agentはより個別化され正確な旅行提案を提供し、全体的なユーザー体験を向上させることができます。

---
```
```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
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` メソッド)**:
   このメソッドは、事前にロードされたコンテキスト辞書から関連情報を取得します。事前にコンテキストをロードすることで、旅行代理店アプリケーションはリアルタイムで外部ソースから情報を取得することなく、ユーザーのクエリに迅速に応答できます。これにより、アプリケーションはより効率的で応答性が高くなります。

### ゴールを設定してからの計画のブートストラップ
ゴールを設定して計画をブートストラップするとは、明確な目標や期待する成果を最初に設定することを指します。このゴールを定義することで、モデルは反復プロセス全体を通じてこれを指針として使用できます。このアプローチにより、各反復が目標達成に向けて進むことを保証し、プロセスがより効率的かつ集中化されます。

以下は、旅行代理店がゴールを設定して計画をブートストラップし、反復を行う例です:

### シナリオ
旅行代理店が顧客のためにカスタマイズされた休暇プランを作成したいとします。目標は、顧客の満足度を最大化する旅行日程を作成することです。

### ステップ
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は旅行先を再ランク付けし、スコアリングすることで、最も関連性の高い選択肢が提示されるようにします。

#### ステップ:
1. ユーザーの好みを収集します。
2. 潜在的な旅行先のリストを取得します。
3. LLMを使用して、ユーザーの好みに基づいて旅行先を再ランク付けしスコアリングします。

以下は、Azure OpenAI Servicesを使用して前述の例を更新する方法です:

#### 必要条件
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)
```

#### コード説明 - Preference Booker
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（Structured Query Language）はデータベースと対話するための強力なツールです。RAG（Retrieval-Augmented Generation）アプローチの一部として使用される場合、SQLはデータベースから関連データを取得し、AIエージェントの応答やアクションに情報を提供できます。

#### 重要な概念

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をRAG技術の一部として活用することで、旅行代理店のようなAIエージェントは関連性の高いデータを動的に取得し、正確で個人化された推奨を提供できます。

### 結論

メタ認知はAIエージェントの能力を大幅に向上させる強力なツールです。メタ認知プロセスを組み込むことで、より知的で適応性が高く効率的なエージェントを設計できます。追加のリソースを活用して、AIエージェントにおけるメタ認知の魅力的な世界をさらに探求してください。
```

**免責事項**:
本書類は、機械翻訳AIサービスを使用して翻訳されています。正確性を追求しておりますが、自動翻訳にはエラーや不正確な部分が含まれる可能性があります。原文（元の言語で記載された文書）を公式な情報源としてご参照ください。重要な情報については、専門の人間による翻訳をお勧めします。本翻訳の利用により生じた誤解や誤解釈について、当方は一切の責任を負いません。


# 本番環境でのAIエージェント

## はじめに

このレッスンでは以下を学びます：

- AIエージェントを本番環境に効果的にデプロイするための計画方法。
- AIエージェントを本番環境にデプロイする際に直面する可能性のある一般的なミスや問題。
- パフォーマンスを維持しつつ、コストを管理する方法。

## 学習目標

このレッスンを終えた後には、以下のことを理解し、実行できるようになります：

- 本番環境でのAIエージェントシステムのパフォーマンス、コスト、効果を向上させるための手法。
- AIエージェントの評価内容と評価方法。
- AIエージェントを本番環境にデプロイする際のコスト管理方法。

信頼できるAIエージェントをデプロイすることは非常に重要です。「Building Trustworthy AI Agents（信頼できるAIエージェントを構築する）」のレッスンもぜひ確認してください。

## AIエージェントの評価

AIエージェントをデプロイする前、デプロイ中、そしてデプロイ後には、適切な評価システムを持つことが重要です。これにより、システムが自分自身やユーザーの目標に沿っていることを確認できます。

AIエージェントを評価する際には、エージェントの出力だけでなく、エージェントが動作するシステム全体を評価できる能力が必要です。これには以下が含まれますが、これらに限定されません：

- 初期のモデルリクエスト。
- ユーザーの意図を正確に把握するエージェントの能力。
- タスクを実行するための適切なツールを特定するエージェントの能力。
- エージェントのリクエストに対するツールの応答。
- ツールの応答を解釈するエージェントの能力。
- エージェントの応答に対するユーザーからのフィードバック。

これにより、改善が必要な領域をよりモジュール的に特定することができます。その後、モデル、プロンプト、ツール、その他のコンポーネントの変更による影響を効率よくモニタリングすることが可能になります。

## AIエージェントにおける一般的な問題とその解決策

| **問題**                                      | **解決策**                                                                                |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| タスクを一貫して実行しないAIエージェント       | - AIエージェントに与えるプロンプトを改善し、目的を明確にする。
- タスクをサブタスクに分割し、複数のエージェントで処理することで効果的になる場合を検討する。                                                      |
| AIエージェントが無限ループに陥る              | - プロセスを終了する条件を明確に設定し、エージェントが停止タイミングを認識できるようにする。
- 推論や計画を必要とする複雑なタスクの場合、推論に特化した大規模モデルを使用する。                               |
| ツール呼び出しがうまく機能しない               | - エージェントシステムの外でツールの出力をテスト・検証する。
- 定義されたパラメータ、プロンプト、ツールの名前付けを改善する。                                                                                |
| マルチエージェントシステムが一貫して動作しない | - 各エージェントに与えるプロンプトを精査し、それぞれが具体的かつ明確に異なるようにする。
- "ルーティング" またはコントローラーエージェントを使用して、どのエージェントが適切かを判断する階層型システムを構築する。 |

## コスト管理

AIエージェントを本番環境にデプロイする際のコストを管理するための戦略は以下の通りです：

- **レスポンスのキャッシュ** - 一般的なリクエストやタスクを特定し、それらのレスポンスをエージェントシステムを通さずに提供することで、類似したリクエストの量を減らすことができます。さらに、基本的なAIモデルを使用してリクエストがキャッシュされたリクエストにどれだけ類似しているかを識別するフローを実装することも可能です。

- **小規模モデルの使用** - 小規模言語モデル（SLM）は、特定のエージェントユースケースで良好なパフォーマンスを発揮し、コストを大幅に削減することができます。前述の通り、評価システムを構築して、大規模モデルとのパフォーマンス比較を行い、自分のユースケースでSLMがどの程度うまく機能するかを理解するのが最善です。

- **ルーターモデルの使用** - 類似した戦略として、さまざまなモデルやサイズを使用する方法があります。LLM/SLMやサーバーレス関数を使用してリクエストを複雑さに基づいて最適なモデルにルーティングすることで、コストを削減しつつ、適切なタスクでのパフォーマンスを確保できます。

## おめでとうございます

これで「AI Agents for Beginners」の最後のレッスンが終了しました。

私たちは、この急速に成長する業界の変化やフィードバックに基づいて、今後もレッスンを追加していく予定ですので、ぜひまたお越しください。

AIエージェントについてさらに学び、構築を続けたい場合は、[Azure AI Community Discord](https://discord.gg/kzRShWzttr) に参加してください。

ここでは、ワークショップ、コミュニティラウンドテーブル、"何でも質問" セッションを開催しています。

また、AIエージェントを本番環境で構築するための追加資料が含まれたLearnコレクションもご用意しています。

**免責事項**:
本書類は、機械翻訳AIサービスを使用して翻訳されています。正確性を期しておりますが、自動翻訳にはエラーや不正確な部分が含まれる可能性があることをご承知おきください。原文（原言語の文書）が公式で信頼できる情報源とみなされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。本翻訳の使用に起因する誤解や解釈の相違について、当方は一切の責任を負いかねます。


# 코스 설정

## 소개

이 강의에서는 코스의 코드 샘플을 실행하는 방법에 대해 다룹니다.

## 요구 사항

- GitHub 계정
- Python 3.12+

## 이 저장소를 클론하거나 포크하기

시작하려면 GitHub 저장소를 클론하거나 포크하세요. 이렇게 하면 코스 자료의 자신의 버전을 만들어 코드를 실행하고, 테스트하고, 수정할 수 있습니다!

이 작업은 [fork the repo](https://github.com/microsoft/ai-agents-for-beginners/fork) 링크를 클릭하여 수행할 수 있습니다.

이제 아래와 같이 강의의 포크된 버전을 가지게 될 것입니다:

![Forked Repo](../../../translated_images/forked-repo.eea246a73044cc984a1e462349e36e7336204f00785e3187b7399905feeada07.ko.png)

## GitHub Personal Access Token (PAT) 가져오기

현재 이 강의는 GitHub Models Marketplace를 사용하여 대형 언어 모델(LLMs)에 무료로 접근할 수 있는 서비스를 제공합니다. 이 모델들은 AI 에이전트를 생성하는 데 사용됩니다.

이 서비스를 사용하려면 GitHub Personal Access Token을 생성해야 합니다.

GitHub 계정에서 [Personal Access Tokens settings](https://github.com/settings/personal-access-tokens)으로 이동하여 생성할 수 있습니다.

화면 왼쪽에서 `Fine-grained tokens` 옵션을 선택하세요.

그런 다음 `Generate new token`를 선택하세요.

![Generate Token](../../../translated_images/generate-token.361ec40abe59b84ac68d63c23e2b6854d6fad82bd4e41feb98fc0e6f030e8ef7.ko.png)

방금 생성한 새 토큰을 복사하세요. 이 토큰을 이 강의에 포함된 `.env` 파일에 추가하게 됩니다.

## 환경 변수에 추가하기

`.env` 파일을 생성하려면 터미널에서 아래 명령을 실행하세요:

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

이 명령은 예제 파일을 복사하여 디렉토리에 `.env` 파일을 생성합니다.

그 파일을 열고 생성한 토큰을 .env 파일의 `GITHUB_TOKEN=` 필드에 붙여넣으세요.

## 필요한 패키지 설치하기

코드를 실행하는 데 필요한 모든 Python 패키지를 설치하려면 터미널에 다음 명령을 실행하세요.

Python 가상 환경을 생성하여 충돌 및 문제를 방지하는 것을 권장합니다.

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

이 명령은 필요한 Python 패키지를 설치할 것입니다.

이제 코드를 실행할 준비가 되었습니다. AI 에이전트의 세계를 더 배워보세요!

설정 중 문제가 발생하면 [Azure AI Community Discord](https://discord.gg/kzRShWzttr)에서 도움을 요청하거나 [create an issue](https://github.com/microsoft/ai-agents-for-beginners/issues?WT.mc_id=academic-105485-koreyst)를 통해 문제를 보고하세요.
```

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


# AI 에이전트 및 에이전트 활용 사례 소개

"초보자를 위한 AI 에이전트" 과정에 오신 것을 환영합니다! 이 과정은 AI 에이전트를 구축하기 위한 기본 지식과 실제 예제를 제공합니다.

다른 학습자 및 AI 에이전트 개발자들과 만나고, 이 과정에 대한 질문을 할 수 있는 [Azure AI Discord 커뮤니티](https://discord.gg/kzRShWzttr)에 참여하세요.

이 과정을 시작하기 전에, AI 에이전트란 무엇인지, 그리고 우리가 구축하는 애플리케이션 및 워크플로에서 이를 어떻게 활용할 수 있는지 더 잘 이해해 보겠습니다.

## 소개

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

- AI 에이전트란 무엇이며, 어떤 유형의 에이전트가 있는가?
- AI 에이전트에 적합한 활용 사례는 무엇이며, 이를 통해 어떤 도움을 받을 수 있는가?
- 에이전트 솔루션을 설계할 때 기본적으로 필요한 요소는 무엇인가?

## 학습 목표

이 강의를 마치면 다음을 할 수 있습니다:

- AI 에이전트 개념을 이해하고, 이를 다른 AI 솔루션과 비교할 수 있습니다.
- AI 에이전트를 가장 효율적으로 활용할 수 있습니다.
- 사용자와 고객 모두에게 생산적인 에이전트 솔루션을 설계할 수 있습니다.

## AI 에이전트 정의 및 유형

### AI 에이전트란 무엇인가?

AI 에이전트는 **시스템**으로, **대규모 언어 모델(LLM)**에 **도구**와 **지식**에 대한 접근 권한을 제공하여 **작업을 수행**할 수 있도록 확장된 기능을 제공합니다.

이 정의를 더 작은 부분으로 나눠보겠습니다:

- **시스템** - 에이전트를 단일 구성 요소로 생각하는 것이 아니라 여러 구성 요소로 이루어진 시스템으로 이해하는 것이 중요합니다. AI 에이전트의 기본 구성 요소는 다음과 같습니다:
  - **환경** - AI 에이전트가 작동하는 정의된 공간입니다. 예를 들어, 여행 예약 AI 에이전트를 생각해보면, 환경은 에이전트가 작업을 완료하기 위해 사용하는 여행 예약 시스템일 수 있습니다.
  - **센서** - 환경은 정보를 제공하고 피드백을 전달합니다. AI 에이전트는 센서를 사용하여 환경의 현재 상태에 대한 정보를 수집하고 해석합니다. 여행 예약 에이전트의 경우, 호텔 가용성이나 항공편 가격과 같은 정보를 제공받을 수 있습니다.
  - **액추에이터** - AI 에이전트가 환경의 현재 상태를 받으면, 현재 작업에 대해 환경을 변경하기 위해 어떤 작업을 수행할지 결정합니다. 여행 예약 에이전트의 경우, 사용자를 위해 이용 가능한 방을 예약하는 작업이 될 수 있습니다.

![AI 에이전트란 무엇인가?](../../../translated_images/what-are-ai-agents.125520f55950b252a429b04a9f41e0152d4dafa1f1bd9081f4f574631acb759e.ko.png?WT.mc_id=academic-105485-koreyst)

**대규모 언어 모델(LLM)** - 에이전트의 개념은 LLM이 개발되기 전부터 존재했습니다. LLM을 사용하여 AI 에이전트를 구축하는 이점은 인간 언어와 데이터를 해석할 수 있는 능력입니다. 이 능력은 LLM이 환경 정보를 해석하고 환경을 변경하기 위한 계획을 정의할 수 있게 합니다.

**작업 수행** - AI 에이전트 시스템 외부에서는, LLM은 사용자의 프롬프트에 따라 콘텐츠나 정보를 생성하는 상황에 제한됩니다. 그러나 AI 에이전트 시스템 내에서는, LLM이 사용자의 요청을 해석하고 환경 내에서 사용 가능한 도구를 활용하여 작업을 완료할 수 있습니다.

**도구 접근** - LLM이 접근할 수 있는 도구는 1) LLM이 작동하는 환경과 2) AI 에이전트 개발자에 의해 정의됩니다. 예를 들어, 여행 에이전트의 경우, 에이전트의 도구는 예약 시스템에서 제공하는 작업에 의해 제한되며, 개발자는 항공편과 같은 특정 도구 접근을 제한할 수도 있습니다.

**지식** - 환경에서 제공되는 정보 외에도, AI 에이전트는 다른 시스템, 서비스, 도구, 심지어 다른 에이전트로부터 지식을 검색할 수 있습니다. 여행 에이전트의 경우, 이 지식은 고객 데이터베이스에 저장된 사용자의 여행 선호도 정보일 수 있습니다.

### 다양한 에이전트 유형

이제 AI 에이전트의 일반적인 정의를 알았으니, 특정 에이전트 유형과 여행 예약 AI 에이전트에 어떻게 적용될 수 있는지 살펴보겠습니다.

| **에이전트 유형**               | **설명**                                                                                | **예시**                                                                                |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **단순 반사 에이전트**         | 미리 정의된 규칙에 따라 즉각적인 작업을 수행합니다.                                                                               | 여행 에이전트가 이메일의 맥락을 해석하여 여행 불만 사항을 고객 서비스로 전달합니다.                                                                                |
| **모델 기반 반사 에이전트**    | 세계의 모델과 그 모델의 변화를 기반으로 작업을 수행합니다.                                                                       | 여행 에이전트가 과거 가격 데이터에 접근하여 가격 변동이 큰 경로를 우선시합니다.                                                                                |
| **목표 기반 에이전트**         | 특정 목표를 달성하기 위해 계획을 세우고, 목표를 해석하여 이를 달성하기 위한 작업을 결정합니다.                                   | 여행 에이전트가 현재 위치에서 목적지까지 필요한 여행 준비(차량, 대중교통, 항공편)를 결정하여 여정을 예약합니다.                                                                                |
| **효용 기반 에이전트**         | 선호도를 고려하고, 수치적으로 트레이드오프를 평가하여 목표를 달성하는 방법을 결정합니다.                                         | 여행 에이전트가 편리함과 비용을 비교하여 최적의 여행을 예약합니다.                                                                                |
| **학습 에이전트**              | 피드백에 응답하여 시간이 지남에 따라 작업을 조정하고 개선합니다.                                                                 | 여행 에이전트가 여행 후 설문조사에서 받은 고객 피드백을 사용하여 향후 예약을 개선합니다.                                                                                |
| **계층적 에이전트**            | 다중 에이전트를 계층 시스템에서 구성하며, 상위 에이전트가 작업을 하위 에이전트가 완료할 하위 작업으로 나눕니다.                 | 여행 에이전트가 여행을 취소할 때 작업을 하위 작업(예: 특정 예약 취소)으로 나누고, 하위 에이전트가 이를 완료한 후 상위 에이전트에 보고합니다.                                                                                |
| **다중 에이전트 시스템(MAS)**   | 에이전트가 독립적으로 작업을 완료하며, 협력하거나 경쟁할 수 있습니다.                                                             | 협력적: 여러 에이전트가 호텔, 항공편, 엔터테인먼트와 같은 특정 여행 서비스를 예약합니다. 경쟁적: 여러 에이전트가 공유 호텔 예약 캘린더를 관리하고 고객을 호텔에 예약하기 위해 경쟁합니다.                                             |

## AI 에이전트를 사용할 때

앞서 여행 에이전트 사례를 사용하여 다양한 에이전트 유형이 여행 예약의 다양한 시나리오에서 어떻게 사용될 수 있는지 설명했습니다. 이 애플리케이션은 과정 전반에 걸쳐 계속 사용할 것입니다.

AI 에이전트가 가장 적합한 활용 사례 유형을 살펴보겠습니다:

![AI 에이전트를 사용할 때?](../../../translated_images/when-to-use-ai-agents.912b9a02e9e0e2af45a3e24faa4e912e334ec23f21f0cf5cb040b7e899b09cd0.ko.png?WT.mc_id=academic-105485-koreyst)

- **개방형 문제** - 워크플로에 작업 단계를 항상 하드코딩할 수 없기 때문에, LLM이 작업을 완료하기 위해 필요한 단계를 스스로 결정하도록 허용합니다.
- **다중 단계 프로세스** - 단일 조회로 해결할 수 없는 도구나 정보를 여러 차례 사용해야 하는 복잡한 작업입니다.
- **시간에 따른 개선** - 에이전트가 환경이나 사용자로부터 피드백을 받아 시간이 지남에 따라 더 나은 효용을 제공할 수 있는 작업입니다.

AI 에이전트를 사용하는 추가적인 고려 사항은 "신뢰할 수 있는 AI 에이전트 구축" 강의에서 다룹니다.

## 에이전트 솔루션의 기본

### 에이전트 개발

AI 에이전트 시스템을 설계하는 첫 번째 단계는 도구, 작업, 행동을 정의하는 것입니다. 이 과정에서는 **Azure AI 에이전트 서비스**를 사용하여 에이전트를 정의하는 방법에 중점을 둡니다. 이 서비스는 다음과 같은 기능을 제공합니다:

- OpenAI, Mistral, Llama와 같은 오픈 모델 선택
- Tripadvisor와 같은 제공자를 통한 라이선스 데이터 사용
- 표준화된 OpenAPI 3.0 도구 사용

### 에이전트 패턴

LLM과의 통신은 프롬프트를 통해 이루어집니다. AI 에이전트는 반자동적인 특성을 가지므로, 환경 변화 이후에 LLM을 수동으로 다시 프롬프트하는 것이 항상 가능하거나 필요하지는 않습니다. 우리는 LLM을 여러 단계에 걸쳐 더 확장 가능하게 프롬프트할 수 있도록 하는 **에이전트 패턴**을 사용합니다.

이 과정은 현재 널리 사용되는 에이전트 패턴을 몇 가지로 나누어 진행됩니다.

### 에이전트 프레임워크

에이전트 프레임워크는 개발자가 코드로 에이전트 패턴을 구현할 수 있도록 합니다. 이러한 프레임워크는 템플릿, 플러그인, 도구를 제공하여 AI 에이전트 간의 협업을 개선합니다. 이를 통해 AI 에이전트 시스템의 관찰성과 문제 해결 능력을 향상시킬 수 있습니다.

이 과정에서는 연구 기반의 AutoGen 프레임워크와 실제 사용 가능한 Semantic Kernel의 Agent 프레임워크를 탐구할 것입니다.

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


# AI 에이전트 프레임워크 탐구하기

AI 에이전트 프레임워크는 AI 에이전트를 쉽게 생성, 배포, 관리할 수 있도록 설계된 소프트웨어 플랫폼입니다. 이러한 프레임워크는 개발자들에게 사전 구축된 컴포넌트, 추상화 및 도구를 제공하여 복잡한 AI 시스템 개발을 간소화합니다.

이 프레임워크는 AI 에이전트 개발에서 공통적으로 발생하는 문제를 표준화된 방식으로 해결하여 개발자가 애플리케이션의 고유한 측면에 집중할 수 있도록 돕습니다. 이를 통해 AI 시스템 구축에서 확장성, 접근성, 효율성이 향상됩니다.

## 소개

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

- AI 에이전트 프레임워크란 무엇이며, 개발자들이 이를 통해 무엇을 할 수 있는가?
- 팀이 이를 사용하여 에이전트의 기능을 빠르게 프로토타입하고, 반복하고, 개선할 수 있는 방법은 무엇인가?
- 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)) 간의 차이점은 무엇인가?
- 기존 Azure 에코시스템 도구를 직접 통합할 수 있는가, 아니면 별도의 솔루션이 필요한가?
- Azure AI Agents 서비스란 무엇이며, 이것이 어떻게 도움이 되는가?

## 학습 목표

이번 강의의 목표는 다음을 이해하는 것입니다:

- AI 에이전트 프레임워크가 AI 개발에서 가지는 역할.
- AI 에이전트 프레임워크를 활용하여 지능형 에이전트를 구축하는 방법.
- AI 에이전트 프레임워크로 활성화되는 주요 기능.
- Autogen, Semantic Kernel, Azure AI Agent Service 간의 차이점.

## AI 에이전트 프레임워크란 무엇이며, 개발자들이 이를 통해 무엇을 할 수 있는가?

전통적인 AI 프레임워크는 AI를 앱에 통합하고 앱의 성능을 다음과 같은 방식으로 향상시킬 수 있도록 도와줍니다:

- **개인화**: AI는 사용자 행동과 선호도를 분석하여 개인화된 추천, 콘텐츠, 경험을 제공합니다.
  예: Netflix와 같은 스트리밍 서비스는 시청 기록을 기반으로 영화를 추천하여 사용자 만족도를 높입니다.
- **자동화 및 효율성**: AI는 반복적인 작업을 자동화하고 워크플로를 간소화하며 운영 효율성을 향상시킬 수 있습니다.
  예: 고객 서비스 앱은 AI 기반 챗봇을 활용하여 일반적인 문의를 처리하고, 응답 시간을 단축하며, 복잡한 문제는 인간 상담원이 처리할 수 있도록 합니다.
- **향상된 사용자 경험**: AI는 음성 인식, 자연어 처리, 예측 텍스트와 같은 지능형 기능을 제공하여 전반적인 사용자 경험을 개선합니다.
  예: Siri와 Google Assistant와 같은 가상 비서는 AI를 활용하여 음성 명령을 이해하고 응답하여 사용자와의 상호작용을 더 쉽게 만듭니다.

### 모두 훌륭해 보이지만, 왜 AI 에이전트 프레임워크가 필요한가요?

AI 에이전트 프레임워크는 단순한 AI 프레임워크 이상의 것을 제공합니다. 이 프레임워크는 사용자가 지정한 목표를 달성하기 위해 사용자, 다른 에이전트, 환경과 상호작용할 수 있는 지능형 에이전트를 생성할 수 있도록 설계되었습니다. 이러한 에이전트는 자율적으로 행동하고, 의사 결정을 내리며, 변화하는 상황에 적응할 수 있습니다. 다음은 AI 에이전트 프레임워크가 제공하는 주요 기능입니다:

- **에이전트 간 협업 및 조정**: 여러 AI 에이전트를 생성하여 협력, 커뮤니케이션, 조정을 통해 복잡한 작업을 해결할 수 있습니다.
- **작업 자동화 및 관리**: 다단계 워크플로의 자동화, 작업 위임, 에이전트 간 동적 작업 관리를 위한 메커니즘을 제공합니다.
- **맥락 이해 및 적응**: 에이전트가 맥락을 이해하고, 변화하는 환경에 적응하며, 실시간 정보를 기반으로 의사 결정을 내릴 수 있는 기능을 제공합니다.

결론적으로, 에이전트는 더 많은 일을 가능하게 하고, 자동화를 한 단계 더 발전시키며, 환경에서 학습하고 적응할 수 있는 더 지능적인 시스템을 만들 수 있게 합니다.

## 에이전트의 기능을 빠르게 프로토타입하고, 반복하고, 개선하는 방법은?

이 분야는 빠르게 발전하고 있지만, 대부분의 AI 에이전트 프레임워크에서 공통적으로 활용할 수 있는 몇 가지 요소가 있습니다. 모듈형 컴포넌트, 협업 도구, 실시간 학습이 그 예입니다. 자세히 살펴보겠습니다:

- **모듈형 컴포넌트 사용**: AI 프레임워크는 프롬프트, 파서, 메모리 관리와 같은 사전 구축된 컴포넌트를 제공합니다.
- **협업 도구 활용**: 특정 역할과 작업을 가진 에이전트를 설계하여 협업 워크플로를 테스트하고 개선할 수 있습니다.
- **실시간 학습**: 피드백 루프를 구현하여 에이전트가 상호작용에서 학습하고 동적으로 행동을 조정하도록 합니다.

### 모듈형 컴포넌트 사용

LangChain 및 Microsoft Semantic Kernel과 같은 프레임워크는 프롬프트, 파서, 메모리 관리와 같은 사전 구축된 컴포넌트를 제공합니다.

**팀이 이를 사용하는 방법**: 팀은 이러한 컴포넌트를 빠르게 조립하여 기능적인 프로토타입을 만들 수 있습니다. 이는 처음부터 시작하지 않고도 빠르게 실험하고 반복할 수 있도록 합니다.

**실제 작동 방식**: 사전 구축된 파서를 사용하여 사용자 입력에서 정보를 추출하거나, 메모리 모듈을 사용하여 데이터를 저장 및 검색하거나, 프롬프트 생성기를 사용하여 사용자와 상호작용할 수 있습니다. 이를 통해 고수준의 논리에 집중할 수 있습니다.

**예제 코드**. 사용자 입력에서 정보를 추출하기 위해 사전 구축된 파서를 사용하는 예제를 살펴보겠습니다:

```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'}
```

이 예제에서 볼 수 있듯이, 사전 구축된 파서를 활용하여 비행 예약 요청의 출발지, 목적지, 날짜와 같은 주요 정보를 추출할 수 있습니다. 이러한 모듈형 접근 방식은 고수준의 논리에 집중할 수 있게 합니다.

### 협업 도구 활용

CrewAI 및 Microsoft Autogen과 같은 프레임워크는 여러 에이전트를 생성하여 협력할 수 있도록 지원합니다.

**팀이 이를 사용하는 방법**: 팀은 특정 역할과 작업을 가진 에이전트를 설계하여 협업 워크플로를 테스트하고 개선하며, 전체 시스템 효율성을 높일 수 있습니다.

**실제 작동 방식**: 데이터 검색, 분석, 의사 결정과 같은 특정 기능을 가진 에이전트 팀을 생성할 수 있습니다. 이러한 에이전트는 정보를 공유하고 사용자 질의에 응답하거나 작업을 완료하기 위해 협력할 수 있습니다.

**예제 코드 (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)
```

위 코드에서 볼 수 있듯이, 여러 에이전트가 데이터를 분석하는 작업을 함께 수행하도록 설계할 수 있습니다. 각 에이전트는 특정 기능을 수행하며, 협력을 통해 원하는 결과를 달성합니다. 특정 역할을 가진 에이전트를 생성함으로써 작업 효율성과 성능을 향상시킬 수 있습니다.

### 실시간 학습

고급 프레임워크는 실시간 맥락 이해 및 적응 기능을 제공합니다.

**팀이 이를 사용하는 방법**: 팀은 피드백 루프를 구현하여 에이전트가 상호작용에서 학습하고 동적으로 행동을 조정하도록 하여 지속적으로 능력을 개선하고 정제할 수 있습니다.

**실제 작동 방식**: 에이전트는 사용자 피드백, 환경 데이터, 작업 결과를 분석하여 지식 기반을 업데이트하고, 의사 결정 알고리즘을 조정하며, 성능을 개선합니다. 이러한 반복 학습 프로세스를 통해 에이전트는 변화하는 조건과 사용자 선호도에 적응하며, 시스템의 전반적인 효과를 향상시킬 수 있습니다.

## Autogen, Semantic Kernel, Azure AI Agent Service 간의 차이점은 무엇인가?

이 프레임워크들을 비교하는 방법은 여러 가지가 있지만, 설계, 기능, 주요 사용 사례 측면에서 몇 가지 핵심 차이점을 살펴보겠습니다:

## Autogen

Microsoft Research의 AI Frontiers Lab에서 개발한 오픈소스 프레임워크입니다. 이벤트 기반, 분산된 *에이전트 기반* 애플리케이션에 중점을 두며, 여러 LLM 및 SLM, 도구, 고급 다중 에이전트 설계 패턴을 지원합니다.

Autogen은 에이전트를 중심으로 설계되었습니다. 에이전트는 환경을 인식하고, 의사 결정을 내리고, 특정 목표를 달성하기 위해 행동하는 자율적인 엔터티입니다. 에이전트는 비동기 메시지를 통해 통신하여 독립적이고 병렬로 작업할 수 있으며, 시스템의 확장성과 응답성을 향상시킵니다.

에이전트는 [액터 모델](https://en.wikipedia.org/wiki/Actor_model)을 기반으로 합니다. Wikipedia에 따르면, 액터는 _동시 계산의 기본 구성 요소로서, 수신된 메시지에 응답하여 로컬 결정을 내리고, 새로운 액터를 생성하며, 메시지를 보내고, 다음 메시지에 어떻게 응답할지 결정할 수 있습니다._

**사용 사례**: 코드 생성 자동화, 데이터 분석 작업, 계획 및 연구 기능을 위한 맞춤형 에이전트 구축.

Autogen의 핵심 개념에 대한 설명은 계속됩니다...
```
```markdown
프로젝트 목표를 기반으로 합니다. 자연어 이해 및 콘텐츠 생성에 이상적입니다.
- **Azure AI Agent Service**: 유연한 모델, 엔터프라이즈 보안 메커니즘, 데이터 저장 방법. 엔터프라이즈 애플리케이션에서 안전하고 확장 가능하며 유연한 AI 에이전트 배포에 이상적입니다.

## 기존 Azure 에코시스템 도구를 직접 통합할 수 있나요, 아니면 독립형 솔루션이 필요하나요?
답은 예입니다. Azure AI Agent Service는 다른 Azure 서비스와 원활하게 작동하도록 설계되었기 때문에 기존 Azure 에코시스템 도구를 직접 통합할 수 있습니다. 예를 들어 Bing, Azure AI Search, Azure Functions를 통합할 수 있습니다. 또한 Azure AI Foundry와 깊은 통합이 가능합니다.

Autogen 및 Semantic Kernel의 경우에도 Azure 서비스와 통합할 수 있지만, 이를 위해 코드에서 Azure 서비스를 호출해야 할 수 있습니다. 또 다른 통합 방법은 Azure SDK를 사용하여 에이전트에서 Azure 서비스와 상호 작용하는 것입니다.

추가적으로, 앞서 언급했듯이 Autogen 또는 Semantic Kernel에서 구축된 에이전트를 위한 오케스트레이터로 Azure AI Agent Service를 사용할 수 있으며, 이를 통해 Azure 에코시스템에 쉽게 접근할 수 있습니다.

## 참고 문헌
- [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)
```

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


# AI 에이전트 설계 원칙

## 소개

AI 에이전트 시스템을 구축하는 방법에는 여러 가지가 있습니다. 생성형 AI 설계에서 모호성이 결함이 아니라 특징이라는 점을 고려할 때, 엔지니어들이 어디서부터 시작해야 할지 막막해하는 경우가 많습니다. 우리는 개발자들이 고객 중심의 에이전트 시스템을 설계하여 비즈니스 요구를 해결할 수 있도록 돕는 인간 중심의 UX 설계 원칙을 만들었습니다. 이 설계 원칙은 처방적인 아키텍처가 아니라, 에이전트 경험을 정의하고 구축하려는 팀에게 출발점을 제공하기 위한 것입니다.

일반적으로, 에이전트는 다음을 목표로 해야 합니다:

- 인간의 역량을 확장하고 규모를 키우기 (브레인스토밍, 문제 해결, 자동화 등)
- 지식 격차 메우기 (새로운 지식 영역 습득, 번역 등)
- 우리가 다른 사람들과 협업하는 방식을 지원하고 촉진하기
- 더 나은 자신이 되도록 돕기 (예: 라이프 코치/작업 관리자, 감정 조절 및 마음챙김 기술 학습 지원, 회복력 구축 등)

## 이 강의에서 다룰 내용

- 에이전트 설계 원칙이란 무엇인가
- 이 설계 원칙을 구현할 때 따라야 할 가이드라인
- 설계 원칙을 활용한 사례

## 학습 목표

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

1. 에이전트 설계 원칙이 무엇인지 설명할 수 있다
2. 에이전트 설계 원칙을 사용할 때의 가이드라인을 설명할 수 있다
3. 에이전트 설계 원칙을 사용하여 에이전트를 구축하는 방법을 이해할 수 있다

## 에이전트 설계 원칙

![에이전트 설계 원칙](../../../translated_images/agentic-design-principles.9f32a64bb6e2aa5a1bdffb70111aa724058bc248b1a3dd3c6661344015604cff.ko.png?WT.mc_id=academic-105485-koreyst)

### 에이전트 (공간)

이는 에이전트가 작동하는 환경을 의미합니다. 이러한 원칙은 물리적 및 디지털 세계에서의 에이전트 설계를 안내합니다.

- **연결하되 붕괴시키지 않기** – 사람들, 이벤트, 실행 가능한 지식을 연결하여 협업과 연결을 가능하게 한다.
  - 에이전트는 이벤트, 지식, 사람들을 연결하는 데 도움을 준다.
  - 에이전트는 사람들을 더 가까이 연결한다. 사람을 대체하거나 폄하하기 위해 설계된 것이 아니다.
- **쉽게 접근 가능하지만 때로는 보이지 않게** – 에이전트는 주로 배경에서 작동하며, 관련성과 적절함이 있을 때만 사용자에게 신호를 보낸다.
  - 에이전트는 모든 디바이스나 플랫폼에서 인증된 사용자에게 쉽게 발견되고 접근 가능해야 한다.
  - 에이전트는 다중 모드 입력 및 출력(소리, 음성, 텍스트 등)을 지원한다.
  - 에이전트는 사용자 요구를 감지하여 전경과 배경, 능동적 상태와 수동적 상태를 원활히 전환할 수 있다.
  - 에이전트는 보이지 않는 형태로 작동할 수 있지만, 그 배경 프로세스 경로와 다른 에이전트와의 협업은 사용자에게 투명하고 제어 가능해야 한다.

### 에이전트 (시간)

이는 에이전트가 시간에 따라 작동하는 방식을 의미합니다. 이러한 원칙은 과거, 현재, 미래에 걸쳐 상호작용하는 에이전트를 설계하는 데 도움을 줍니다.

- **과거**: 상태와 맥락을 포함한 역사를 반영하기.
  - 에이전트는 단순히 이벤트, 사람 또는 상태뿐만 아니라 더 풍부한 역사적 데이터를 분석하여 더 관련성 높은 결과를 제공한다.
  - 에이전트는 과거 이벤트에서 연결을 생성하고, 현재 상황에 참여하기 위해 기억을 적극적으로 반영한다.
- **현재**: 알림을 넘어 유도하기.
  - 에이전트는 사람들과 상호작용하는 데 있어 종합적인 접근 방식을 구현한다. 이벤트가 발생했을 때, 단순한 알림이나 형식적인 방식에 그치지 않고, 사용자 주의를 적시에 끌 수 있도록 동적 신호를 생성하거나 흐름을 단순화한다.
  - 에이전트는 맥락 환경, 사회적/문화적 변화, 사용자 의도에 맞춰 정보를 전달한다.
  - 에이전트와의 상호작용은 점진적이고, 장기적으로 사용자에게 권한을 부여할 수 있도록 복잡성이 진화/성장할 수 있다.
- **미래**: 적응하고 진화하기.
  - 에이전트는 다양한 디바이스, 플랫폼, 모달리티에 적응한다.
  - 에이전트는 사용자 행동, 접근성 요구에 적응하며, 자유롭게 사용자화할 수 있다.
  - 에이전트는 지속적인 사용자 상호작용을 통해 형성되고 진화한다.

### 에이전트 (핵심)

이는 에이전트 설계의 핵심 요소들입니다.

- **불확실성을 수용하되 신뢰를 구축하기**.
  - 에이전트 설계에서 어느 정도의 불확실성은 예상된다. 불확실성은 에이전트 설계의 중요한 요소이다.
  - 신뢰와 투명성은 에이전트 설계의 기본적인 층이다.
  - 에이전트가 켜져 있거나 꺼져 있는 상태는 항상 명확히 표시되며, 인간이 이를 제어할 수 있다.

## 이 원칙을 구현하기 위한 가이드라인

위의 설계 원칙을 사용할 때는 다음의 가이드라인을 따르세요:

1. **투명성**: 사용자에게 AI가 포함되어 있음을 알리고, 그것이 어떻게 작동하는지(과거 행동 포함), 피드백 제공 및 시스템 수정 방법을 알려준다.
2. **제어**: 사용자가 시스템 및 속성(예: 잊기 기능 포함)을 사용자화하고 선호도를 지정하며 제어할 수 있도록 한다.
3. **일관성**: 디바이스와 엔드포인트 전반에 걸쳐 일관된 다중 모드 경험을 목표로 한다. 가능한 경우 익숙한 UI/UX 요소를 사용하고(예: 음성 상호작용을 위한 마이크 아이콘), 고객의 인지적 부담을 최대한 줄인다(예: 간결한 응답, 시각적 도움 자료, ‘더 알아보기’ 콘텐츠 제공).

## 이 원칙과 가이드라인을 사용하여 여행 에이전트 설계하기

여행 에이전트를 설계한다고 가정해 봅시다. 다음은 설계 원칙과 가이드라인을 활용하는 방법입니다:

1. **투명성** – 여행 에이전트가 AI 기반 에이전트임을 사용자에게 알립니다. 시작하는 방법에 대한 기본 지침을 제공합니다(예: "안녕하세요" 메시지, 샘플 프롬프트). 이를 제품 페이지에 명확히 문서화합니다. 사용자가 과거에 요청한 프롬프트 목록을 표시합니다. 피드백 제공 방법(좋아요/싫어요 버튼, 피드백 보내기 버튼 등)을 명확히 합니다. 에이전트가 사용 제한이나 주제 제한이 있는 경우 이를 명확히 설명합니다.
2. **제어** – 에이전트를 생성한 후 수정할 수 있는 방법(예: 시스템 프롬프트)을 명확히 합니다. 에이전트의 응답 길이, 글쓰기 스타일, 다루지 말아야 할 주제 등을 사용자가 선택할 수 있도록 합니다. 사용자에게 관련 파일이나 데이터, 프롬프트, 과거 대화를 확인하고 삭제할 수 있는 기능을 제공합니다.
3. **일관성** – 프롬프트 공유, 파일 또는 사진 추가, 태그 지정 등을 나타내는 아이콘이 표준적이고 알아보기 쉽게 만듭니다. 파일 업로드/공유를 나타내는 클립 아이콘과 그래픽 업로드를 나타내는 이미지 아이콘을 사용합니다.

## 추가 자료
- [Practices for Governing Agentic AI Systems | OpenAI](https://openai.com)
- [The HAX Toolkit Project - Microsoft Research](https://microsoft.com)
- [Responsible AI Toolbox](https://responsibleaitoolbox.ai)

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


# 도구 사용 설계 패턴

## 소개

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

- 도구 사용 설계 패턴이란 무엇인가요?
- 이 패턴이 적용될 수 있는 사용 사례는 무엇인가요?
- 이 설계 패턴을 구현하기 위해 필요한 요소/구성 요소는 무엇인가요?
- 신뢰할 수 있는 AI 에이전트를 구축하기 위해 도구 사용 설계 패턴을 사용할 때의 특별한 고려사항은 무엇인가요?

## 학습 목표

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

- 도구 사용 설계 패턴과 그 목적을 정의합니다.
- 도구 사용 설계 패턴이 적용 가능한 사용 사례를 식별합니다.
- 이 설계 패턴을 구현하는 데 필요한 핵심 요소를 이해합니다.
- 이 설계 패턴을 사용하는 AI 에이전트에서 신뢰성을 보장하기 위한 고려사항을 인식합니다.

## 도구 사용 설계 패턴이란 무엇인가요?

**도구 사용 설계 패턴**은 LLM(Large Language Models)이 특정 목표를 달성하기 위해 외부 도구와 상호작용할 수 있도록 하는 데 중점을 둡니다. 도구는 작업을 수행하기 위해 에이전트가 실행할 수 있는 코드입니다. 도구는 계산기와 같은 간단한 함수일 수도 있고, 주식 가격 조회나 날씨 예보와 같은 타사 서비스의 API 호출일 수도 있습니다. AI 에이전트의 맥락에서, 도구는 **모델이 생성한 함수 호출**에 응답하여 에이전트가 실행할 수 있도록 설계됩니다.

## 이 패턴이 적용될 수 있는 사용 사례는 무엇인가요?

AI 에이전트는 도구를 활용하여 복잡한 작업을 완료하거나, 정보를 검색하거나, 결정을 내릴 수 있습니다. 도구 사용 설계 패턴은 데이터베이스, 웹 서비스 또는 코드 해석기와 같은 외부 시스템과 동적으로 상호작용해야 하는 시나리오에서 자주 사용됩니다. 이 능력은 다음과 같은 다양한 사용 사례에서 유용합니다:

- **동적 정보 검색:** 에이전트는 외부 API나 데이터베이스를 쿼리하여 최신 데이터를 가져올 수 있습니다(예: SQLite 데이터베이스를 쿼리하여 데이터 분석, 주식 가격 또는 날씨 정보 검색).
- **코드 실행 및 해석:** 에이전트는 수학 문제를 해결하거나, 보고서를 생성하거나, 시뮬레이션을 수행하기 위해 코드나 스크립트를 실행할 수 있습니다.
- **워크플로 자동화:** 작업 스케줄러, 이메일 서비스, 데이터 파이프라인과 같은 도구를 통합하여 반복적이거나 다단계 워크플로를 자동화합니다.
- **고객 지원:** 에이전트는 CRM 시스템, 티켓 발급 플랫폼 또는 지식 기반과 상호작용하여 사용자 문의를 해결할 수 있습니다.
- **콘텐츠 생성 및 편집:** 에이전트는 문법 검사기, 텍스트 요약기 또는 콘텐츠 안전성 평가기와 같은 도구를 활용하여 콘텐츠 생성 작업을 지원할 수 있습니다.

## 이 설계 패턴을 구현하기 위해 필요한 요소/구성 요소는 무엇인가요?

### 함수/도구 호출

함수 호출은 LLM이 도구와 상호작용할 수 있도록 하는 주요 방법입니다. '함수'와 '도구'라는 용어는 종종 혼용되는데, 이는 '함수'(재사용 가능한 코드 블록)가 에이전트가 작업을 수행하기 위해 사용하는 '도구'이기 때문입니다. 함수의 코드가 호출되기 위해서는 LLM이 사용자 요청을 함수 설명과 비교해야 합니다. 이를 위해 사용 가능한 모든 함수의 설명을 포함한 스키마가 LLM에 전달됩니다. LLM은 작업에 가장 적합한 함수를 선택하고 함수 이름과 인수를 반환합니다. 선택된 함수가 호출되고, 그 응답이 LLM에 다시 전달되어 사용자의 요청에 응답합니다.

에이전트를 위한 함수 호출을 구현하려면 다음이 필요합니다:

1. 함수 호출을 지원하는 LLM 모델
2. 함수 설명을 포함한 스키마
3. 설명된 각 함수의 코드

도시의 현재 시간을 가져오는 예제를 사용해 보겠습니다:

- **함수 호출을 지원하는 LLM 초기화:**

    모든 모델이 함수 호출을 지원하는 것은 아니므로, 사용하는 LLM이 이를 지원하는지 확인하는 것이 중요합니다. [Azure OpenAI](https://learn.microsoft.com/azure/ai-services/openai/how-to/function-calling)는 함수 호출을 지원합니다. Azure OpenAI 클라이언트를 초기화하는 것으로 시작할 수 있습니다.

    ```python
    # Initialize the Azure OpenAI client
    client = AzureOpenAI(
        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"),
        api_key=os.getenv("AZURE_OPENAI_API_KEY"),
        api_version="2024-05-01-preview"
    )
    ```

- **함수 스키마 생성:**

    다음으로, 함수 이름, 함수가 수행하는 작업에 대한 설명, 함수 매개변수의 이름과 설명을 포함하는 JSON 스키마를 정의합니다. 그런 다음 이 스키마를 위에서 생성한 클라이언트와 함께 사용자의 요청(예: 샌프란시스코의 시간을 찾기 위해)과 함께 전달합니다. 중요한 점은 **도구 호출**이 반환된다는 것이며, **최종 답변**이 아니라는 것입니다. 앞서 언급했듯이, LLM은 작업에 대해 선택된 함수 이름과 전달될 인수를 반환합니다.

    ```python
    # Function description for the model to read
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_current_time",
                "description": "Get the current time in a given location",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city name, e.g. San Francisco",
                        },
                    },
                    "required": ["location"],
                },
            }
        }
    ]
    ```

    ```python

    # Initial user message
    messages = [{"role": "user", "content": "What's the current time in San Francisco"}]

    # First API call: Ask the model to use the function
      response = client.chat.completions.create(
          model=deployment_name,
          messages=messages,
          tools=tools,
          tool_choice="auto",
      )

      # Process the model's response
      response_message = response.choices[0].message
      messages.append(response_message)

      print("Model's response:")

      print(response_message)

    ```

    ```bash
    Model's response:
    ChatCompletionMessage(content=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='call_pOsKdUlqvdyttYB67MOj434b', function=Function(arguments='{"location":"San Francisco"}', name='get_current_time'), type='function')])
    ```

- **작업을 수행하기 위한 함수 코드:**

    이제 LLM이 실행할 함수를 선택했으므로, 작업을 수행할 코드를 구현하고 실행해야 합니다. Python으로 현재 시간을 가져오는 코드를 구현할 수 있습니다. 또한 `response_message`에서 이름과 인수를 추출하여 최종 결과를 얻는 코드를 작성해야 합니다.

    ```python
      def get_current_time(location):
        """Get the current time for a given location"""
        print(f"get_current_time called with location: {location}")
        location_lower = location.lower()

        for key, timezone in TIMEZONE_DATA.items():
            if key in location_lower:
                print(f"Timezone found for {key}")
                current_time = datetime.now(ZoneInfo(timezone)).strftime("%I:%M %p")
                return json.dumps({
                    "location": location,
                    "current_time": current_time
                })

        print(f"No timezone data found for {location_lower}")
        return json.dumps({"location": location, "current_time": "unknown"})
    ```

    ```python
     # Handle function calls
      if response_message.tool_calls:
          for tool_call in response_message.tool_calls:
              if tool_call.function.name == "get_current_time":

                  function_args = json.loads(tool_call.function.arguments)

                  time_response = get_current_time(
                      location=function_args.get("location")
                  )

                  messages.append({
                      "tool_call_id": tool_call.id,
                      "role": "tool",
                      "name": "get_current_time",
                      "content": time_response,
                  })
      else:
          print("No tool calls were made by the model.")

      # Second API call: Get the final response from the model
      final_response = client.chat.completions.create(
          model=deployment_name,
          messages=messages,
      )

      return final_response.choices[0].message.content
     ```

    ```bash
      get_current_time called with location: San Francisco
      Timezone found for san francisco
      The current time in San Francisco is 09:24 AM.
     ```

함수 호출은 대부분의, 아니면 모든 에이전트 도구 사용 설계의 핵심에 있지만, 이를 처음부터 구현하는 것은 때로 도전적일 수 있습니다.
[Lesson 2](../../../02-explore-agentic-frameworks)에서 배운 것처럼 에이전트 프레임워크는 도구 사용을 구현하기 위한 사전 구축된 구성 요소를 제공합니다.

### 에이전트 프레임워크를 활용한 도구 사용 예제

- ### **[Semantic Kernel](https://learn.microsoft.com/azure/ai-services/agents/overview)**

    Semantic Kernel은 LLM(Large Language Models)을 사용하는 .NET, Python, Java 개발자를 위한 오픈소스 AI 프레임워크입니다. 이 프레임워크는 [직렬화](https://learn.microsoft.com/semantic-kernel/concepts/ai-services/chat-completion/function-calling/?pivots=programming-language-python#1-serializing-the-functions)라는 과정을 통해 함수와 매개변수를 모델에 자동으로 설명하여 함수 호출 과정을 간소화합니다. 또한, 모델과 코드 간의 통신을 자동으로 처리합니다. Semantic Kernel과 같은 에이전트 프레임워크를 사용하는 또 다른 장점은 [파일 검색](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step4_assistant_tool_file_search.py) 및 [코드 해석기](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step3_assistant_tool_code_interpreter.py)와 같은 사전 구축된 도구를 사용할 수 있다는 점입니다.

    다음 다이어그램은 Semantic Kernel에서의 함수 호출 프로세스를 보여줍니다:

    ![function calling](../../../translated_images/functioncalling-diagram.b5493ea5154ad8e3e4940d2e36a49101eec1398948e5d1039942203b4f5a4209.ko.png)

    Semantic Kernel에서 함수/도구는 [플러그인](https://learn.microsoft.com/semantic-kernel/concepts/plugins/?pivots=programming-language-python)이라고 불립니다. `get_current_time` function we saw earlier into a plugin by turning it into a class with the function in it. We can also import the `kernel_function` 데코레이터를 사용하여 함수 설명을 전달할 수 있습니다. 그런 다음 GetCurrentTimePlugin과 함께 커널을 생성하면 커널이 함수와 매개변수를 자동으로 직렬화하여 LLM에 보낼 스키마를 생성합니다.

    ```python
    from semantic_kernel.functions import kernel_function

    class GetCurrentTimePlugin:
        async def __init__(self, location):
            self.location = location

        @kernel_function(
            description="Get the current time for a given location"
        )
        def get_current_time(location: str = ""):
            ...

    ```

    ```python
    from semantic_kernel import Kernel

    # Create the kernel
    kernel = Kernel()

    # Create the plugin
    get_current_time_plugin = GetCurrentTimePlugin(location)

    # Add the plugin to the kernel
    kernel.add_plugin(get_current_time_plugin)
    ```

- ### **[Azure AI Agent Service](https://learn.microsoft.com/azure/ai-services/agents/overview)**

    Azure AI Agent Service는 개발자가 고품질의 확장 가능한 AI 에이전트를 안전하게 구축, 배포, 확장할 수 있도록 설계된 새로운 에이전트 프레임워크입니다. 이 서비스는 기본 컴퓨팅 및 스토리지 리소스를 관리할 필요가 없기 때문에 특히 엔터프라이즈 애플리케이션에 유용합니다.

    LLM API를 직접 사용하는 것과 비교했을 때, Azure AI Agent Service는 다음과 같은 장점을 제공합니다:
  - 자동 도구 호출 – 도구 호출을 구문 분석하고, 도구를 호출하며, 응답을 처리할 필요가 없음; 모든 작업이 서버 측에서 처리됨
  - 안전하게 관리되는 데이터 – 대화 상태를 직접 관리하는 대신, 스레드를 사용하여 필요한 모든 정보를 저장 가능
  - 기본 제공 도구 – Bing, Azure AI Search, Azure Functions와 같은 데이터 소스와 상호작용할 수 있는 도구 사용 가능

    Azure AI Agent Service에서 사용할 수 있는 도구는 두 가지 범주로 나뉩니다:

    1. 지식 도구:
        - [Bing 검색을 통한 정보 기반](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/bing-grounding?tabs=python&pivots=overview)
        - [파일 검색](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/file-search?tabs=python&pivots=overview)
        - [Azure AI Search](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/azure-ai-search?tabs=azurecli%2Cpython&pivots=overview-azure-ai-search)

    2. 액션 도구:
        - [함수 호출](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/function-calling?tabs=python&pivots=overview)
        - [코드 해석기](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/code-interpreter?tabs=python&pivots=overview)
        - [OpenAI 정의 도구](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/openapi-spec?tabs=python&pivots=overview)
        - [Azure Functions](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/azure-functions?pivots=overview)

    Agent Service를 사용하면 사용자 요청에 따라 `toolset`. It also utilizes `threads` which keep track of the history of messages from a particular conversation.

    Imagine you are a sales agent at a company called Contoso. You want to develop a conversational agent that can answer questions about your sales data.

    The image below illustrates how you could use Azure AI Agent Service to analyze your sales data:

    ![Agentic Service In Action](../../../translated_images/agent-service-in-action.8c2d8aa8e9d91feeb29549b3fde529f8332b243875154d03907616a69198afbc.ko.jpg?WT.mc_id=academic-105485-koreyst)

    To use any of these tools with the service we can create a client and define a tool or toolset. To implement this practically we can use the Python code below. The LLM will be able to look at the toolset and decide whether to use the user created function, `fetch_sales_data_using_sqlite_query` 또는 사전 구축된 코드 해석기를 함께 사용할 수 있습니다.

    ```python
    import os
    from azure.ai.projects import AIProjectClient
    from azure.identity import DefaultAzureCredential
    from fecth_sales_data_functions import fetch_sales_data_using_sqlite_query # fetch_sales_data_using_sqlite_query function which can be found in a fecth_sales_data_functions.py file.
    from azure.ai.projects.models import ToolSet, FunctionTool, CodeInterpreterTool

    project_client = AIProjectClient.from_connection_string(
        credential=DefaultAzureCredential(),
        conn_str=os.environ["PROJECT_CONNECTION_STRING"],
    )

    # Initialize function calling agent with the fetch_sales_data_using_sqlite_query function and adding it to the toolset
    fetch_data_function = FunctionTool(fetch_sales_data_using_sqlite_query)
    toolset = ToolSet()
    toolset.add(fetch_data_function)

    # Initialize Code Interpreter tool and adding it to the toolset.
    code_interpreter = code_interpreter = CodeInterpreterTool()
    toolset = ToolSet()
    toolset.add(code_interpreter)

    agent = project_client.agents.create_agent(
        model="gpt-4o-mini", name="my-agent", instructions="You are helpful agent",
        toolset=toolset
    )
    ```

## 신뢰할 수 있는 AI 에이전트를 구축하기 위해 도구 사용 설계 패턴을 사용할 때의 특별한 고려사항은 무엇인가요?

LLM이 동적으로 생성한 SQL과 관련된 일반적인 우려 사항은 SQL 삽입이나 데이터베이스 삭제 또는 조작과 같은 악의적인 작업의 위험입니다. 이러한 우려는 타당하지만, 데이터베이스 액세스 권한을 적절히 구성하면 효과적으로 완화할 수 있습니다. 대부분의 데이터베이스에서는 데이터베이스를 읽기 전용으로 구성하는 것이 포함됩니다. PostgreSQL 또는 Azure SQL과 같은 데이터베이스 서비스의 경우, 앱에 읽기 전용(SELECT) 역할을 할당해야 합니다.

앱을 안전한 환경에서 실행하면 보호 수준이 더욱 강화됩니다. 엔터프라이즈 시나리오에서는 데이터를 읽기 전용 데이터베이스 또는 사용자 친화적인 스키마를 갖춘 데이터 웨어하우스로 변환하여 운영 시스템에서 데이터를 추출하는 경우가 일반적입니다. 이러한 접근 방식은 데이터를 안전하게 유지하고, 성능과 접근성을 최적화하며, 앱이 제한된 읽기 전용 액세스만 가지도록 보장합니다.

## 추가 자료

- [Azure AI Agents Service Workshop](https://microsoft.github.io/build-your-first-agent-with-azure-ai-agent-service-workshop/)
- [Contoso Creative Writer Multi-Agent Workshop](https://github.com/Azure-Samples/contoso-creative-writer/tree/main/docs/workshop)
- [Semantic Kernel Function Calling Tutorial](https://learn.microsoft.com/semantic-kernel/concepts/ai-services/chat-completion/function-calling/?pivots=programming-language-python#1-serializing-the-functions)
- [Semantic Kernel Code Interpreter](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step3_assistant_tool_code_interpreter.py)
- [Autogen Tools](https://microsoft.github.io/autogen/dev/user-guide/core-user-guide/components/tools.html)
```

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