15 Lessons -- Get Started Building AI Agents. A structured course by Microsoft covering AI agent fundamentals, agentic frameworks, design patterns, tool use, multi-agent systems, production deployment, protocols (MCP/A2A), context engineering, and agent memory.

Introduction

What are AI Agents and what are the different types of agents?
什么是 AI 代理，有哪些不同类型的代理？
What use cases are best for AI Agents and how can they help us?
哪些用例最适合 AI 代理，它们如何帮助我们？
What are some of the basic building blocks when designing Agentic Solutions?
设计代理解决方案 (Agentic Solutions) 时有哪些基本构建块？

Learning Goals

Understand AI Agent concepts and how they differ from other AI solutions.
了解 AI 代理的概念以及它们与其他 AI 解决方案的不同之处。
Apply AI Agents most efficiently.
最有效地应用 AI 代理。
Design Agentic solutions productively for both users and customers.
为用户和客户高效地设计代理解决方案 (Agentic solutions)。

System - It's important to think about agents not as just a single component but as a system of many components. At the basic level, the components of an AI Agent are:
• Environment - The defined space where the AI Agent is operating. For example, if we had a travel booking AI Agent, the environment could be the travel booking system that the AI Agent uses to complete tasks.
系统 - 重要的是，要将代理视为一个由许多组件组成的系统，而不仅仅是一个单独的组件。 在基本层面上，AI 代理的组成部分是： 环境 - AI 代理运行的已定义空间。 例如，如果我们有一个旅游预订 AI 代理，则环境可能是 AI 代理用于完成任务的旅游预订系统。
Sensors - Environments have information and provide feedback. AI Agents use sensors to gather and interpret this information about the current state of the environment. In the Travel Booking Agent example, the travel booking system can provide information such as hotel availability or flight prices.
传感器 - 环境具有信息并提供反馈。 AI 代理使用传感器来收集和解释有关环境当前状态的这些信息。 在旅游预订代理示例中，旅游预订系统可以提供诸如酒店可用性或航班价格之类的信息。
Actuators - Once the AI Agent receives the current state of the environment, for the current task the agent determines what action to perform to change the environment. For the travel booking agent, it might be to book an available room for the user.
执行器 - 一旦 AI 代理接收到环境的当前状态，代理就会针对当前任务确定要执行什么操作来改变环境。 对于旅游预订代理，这可能是为用户预订一个可用的房间。

Open-Ended Problems - allowing the LLM to determine needed steps to complete a task because it can't always be hardcoded into a workflow.
开放式问题 - 允许 LLM 确定完成任务所需的步骤，因为它并非总是可以硬编码到工作流程中。
Multi-Step Processes - tasks that require a level of complexity in which the AI Agent needs to use tools or information over multiple turns instead of single shot retrieval.
多步骤流程 - 需要一定复杂程度的任务，其中 AI 代理需要通过多个回合而不是单次检索来使用工具或信息。
Improvement Over Time - tasks where the agent can improve over time by receiving feedback from either its environment or users in order to provide better utility.
随时间推移而改进 - 代理可以通过接收来自其环境或用户的反馈来随着时间的推移而改进，以便提供更好的实用性。

Selection of Open Models such as OpenAI, Mistral, and Llama
选择开放模型 (Open Models)，例如 OpenAI、Mistral 和 Llama
Use of Licensed Data through providers such as Tripadvisor
通过 Tripadvisor 等提供商使用许可数据 (Licensed Data)
Use of standardized OpenAPI 3.0 tools
使用标准化的 OpenAPI 3.0 工具 (Use of standardized OpenAPI 3.0 tools)

Introduction

Broaden and scale human capacities (brainstorming, problem-solving, automation, etc.)
扩展和扩大人类的能力（集思广益、解决问题、自动化等）
Fill in knowledge gaps (get me up-to-speed on knowledge domains, translation, etc.)
填补知识空白（让我快速了解知识领域、翻译等）
Facilitate and support collaboration in the ways we as individuals prefer to work with others
以我们个人喜欢与他人合作的方式促进和支持协作
Make us better versions of ourselves (e.g., life coach/task master, helping us learn emotional regulation and mindfulness skills, building resilience, etc.)
使我们成为更好的自己（例如，生活教练/任务主管，帮助我们学习情绪调节和正念技巧，培养复原力等）

What are the Agentic Design Principles
什么是 Agentic 设计原则
What are some guidelines to follow while implementing these design principles
实施这些设计原则时应遵循哪些准则
What are some examples of using the design principles
使用设计原则的一些例子是什么

Learning Goals

After completing this lesson, you will be able to:

Explain what the Agentic Design Principles are
解释什么是 Agentic 设计原则
Explain the guidelines for using the Agentic Design Principles
解释使用 Agentic 设计原则的准则
Understand how to build an agent using the Agentic Design Principles
了解如何使用 Agentic 设计原则构建 Agent

Connecting, not collapsing – help connect people to other people, events, and actionable knowledge to enable collaboration and connection.
连接，而不是崩溃——帮助人们连接到其他人、事件和可操作的知识，以实现协作和连接。
Agents help connect events, knowledge, and people.
Agent 帮助连接事件、知识和人。
Agents bring people closer together. They are not designed to replace or belittle people.
Agent 让人们更紧密地联系在一起。 它们并非旨在取代或贬低人。
Easily accessible yet occasionally invisible – agent largely operates in the background and only nudges us when it is relevant and appropriate.
• Agent is easily discoverable and accessible for authorized users on any device or platform.
易于访问但偶尔不可见——Agent 主要在后台运行，仅在相关且适当的时候才会提醒我们。 Agent 在任何设备或平台上都易于发现，并且可供授权用户访问。
Agent supports multimodal inputs and outputs (sound, voice, text, etc.).
Agent 支持多模式输入和输出（声音、语音、文本等）。
Agent can seamlessly transition between foreground and background; between proactive and reactive, depending on its sensing of user needs.
Agent 可以在前台和后台之间、主动和被动之间无缝过渡，具体取决于它对用户需求的感知。
Agent may operate in invisible form, yet its background process path and collaboration with other Agents are transparent to and controllable by the user.
Agent 可以以隐形形式运行，但其后台处理路径以及与其他 Agent 的协作对于用户是透明且可控的。

Past: Reflecting on history that includes both state and context.
• Agent provides more relevant results based on analysis of richer historical data beyond only the event, people, or states.
过去：反思包括状态和背景的历史。 Agent 根据对除事件、人员或状态之外的更丰富的历史数据的分析，提供更相关的结果。
Agent creates connections from past events and actively reflects on memory to engage with current situations.
Agent 从过去的事件创建连接，并主动反思记忆以参与当前的情况。

Embrace uncertainty but establish trust.
• A certain level of Agent uncertainty is expected. Uncertainty is a key element of agent design.
拥抱不确定性，但要建立信任。 一定程度的代理不确定性是可以预期的。 不确定性是代理设计的关键要素。
Trust and transparency are foundational layers of Agent design.
信任和透明是代理设计的基础层。
Humans are in control of when the Agent is on/off and Agent status is clearly visible at all times.
人类可以控制代理的开启/关闭时间，并且代理状态始终清晰可见。

Transparency: Inform the user that AI is involved, how it functions (including past actions), and how to give feedback and modify the system.
透明度 (Transparency)：告知用户 AI 参与其中，它是如何运作的（包括过去的行为），以及如何提供反馈和修改系统。
Control: Enable the user to customize, specify preferences and personalize, and have control over the system and its attributes (including the ability to forget).
控制 (Control)：使用户能够自定义、指定偏好和个性化，并能够控制系统及其属性（包括遗忘能力）。
Consistency: Aim for consistent, multi-modal experiences across devices and endpoints. Use familiar UI/UX elements where possible (e.g., microphone icon for voice interaction) and reduce the customer’s cognitive load as much as possible (e.g., aim for concise responses, visual aids, and ‘Learn More’ content).
一致性 (Consistency)：力求在各种设备和端点上提供一致的多模式 (multi-modal) 体验。 尽可能使用熟悉的 UI/UX 元素（例如，用于语音交互的麦克风图标），并尽可能降低客户的认知负荷（例如，力求简洁的响应、可视化辅助和“了解更多”内容）。

Transparency – Let the user know that the Travel Agent is an AI-enabled Agent. Provide some basic instructions on how to get started (e.g., a “Hello” message, sample prompts). Clearly document this on the product page. Show the list of prompts a user has asked in the past. Make it clear how to give feedback (thumbs up and down, Send Feedback button, etc.). Clearly articulate if the Agent has usage or topic restrictions.
透明度 (Transparency) – 让用户知道旅行代理是一个支持 AI 的代理。 提供一些关于如何开始的基本说明（例如，“Hello”消息、示例提示）。 在产品页面上清楚地记录这一点。 显示用户过去提出的提示列表。 明确说明如何提供反馈（赞和踩、发送反馈按钮等）。 清楚地说明代理是否有使用或主题限制。
Control – Make sure it’s clear how the user can modify the Agent after it’s been created with things like the System Prompt. Enable the user to choose how verbose the Agent is, its writing style, and any caveats on what the Agent should not talk about. Allow the user to view and delete any associated files or data, prompts, and past conversations.
控制 (Control) – 确保用户可以清楚地了解如何在创建代理后通过诸如系统提示 (System Prompt) 之类的东西来修改代理。 使用户能够选择代理的详细程度、其写作风格以及代理不应谈论的任何注意事项。 允许用户查看和删除任何相关的文件或数据、提示和过去的对话。
Consistency – Make sure the icons for Share Prompt, add a file or photo and tag someone or something are standard and recognizable. Use the paperclip icon to indicate file upload/sharing with the Agent, and an image icon to indicate graphics upload.
一致性 (Consistency) – 确保共享提示 (Share Prompt)、添加文件或照片以及标记某人或某物的图标是标准且可识别的。 使用回形针图标表示与代理的文件上传/共享，并使用图像图标表示图形上传。

Introduction

In this lesson, we're looking to answer the following questions:

What is the tool use design pattern?
什么是工具使用设计模式 (tool use design pattern)？
What are the use cases it can be applied to?
它可以应用于哪些用例？
What are the elements/building blocks needed to implement the design pattern?
实施设计模式需要哪些要素/构建块？
What are the special considerations for using the Tool Use Design Pattern to build trustworthy AI agents?
使用工具使用设计模式 (Tool Use Design Pattern) 构建值得信赖的 AI 代理有哪些特殊注意事项？

Learning Goals

Define the Tool Use Design Pattern and its purpose.
定义工具使用设计模式 (Tool Use Design Pattern) 及其目的。
Identify use cases where the Tool Use Design Pattern is applicable.
识别适用工具使用设计模式 (Tool Use Design Pattern) 的用例。
Understand the key elements needed to implement the design pattern.
了解实施设计模式所需的关键要素。
Recognize considerations for ensuring trustworthiness in AI agents using this design pattern.
识别在使用此设计模式的 AI 代理中确保可信度的注意事项。

Dynamic Information Retrieval: Agents can query external APIs or databases to fetch up-to-date data (e.g., querying a SQLite database for data analysis, fetching stock prices or weather information).
动态信息检索 (Dynamic Information Retrieval)：代理可以查询外部 API 或数据库以获取最新数据（例如，查询 SQLite 数据库进行数据分析、获取股票价格或天气信息）。
Code Execution and Interpretation: Agents can execute code or scripts to solve mathematical problems, generate reports, or perform simulations.
代码执行和解释 (Code Execution and Interpretation)：代理可以执行代码或脚本来解决数学问题、生成报告或执行模拟。
Workflow Automation: Automating repetitive or multi-step workflows by integrating tools like task schedulers, email services, or data pipelines.
工作流自动化 (Workflow Automation)：通过集成任务调度器、电子邮件服务或数据管道等工具来自动化重复或多步骤的工作流。
Customer Support: Agents can interact with CRM systems, ticketing platforms, or knowledge bases to resolve user queries.
客户支持： 坐席可以与 CRM 系统（Customer Relationship Management systems）、工单平台 (ticketing platforms) 或知识库进行交互，以解决用户查询。
Content Generation and Editing: Agents can leverage tools like grammar checkers, text summarizers, or content safety evaluators to assist with content creation tasks.
内容生成和编辑： 坐席可以利用语法检查器、文本摘要器或内容安全评估器等工具，来辅助内容创作任务。

Function/Tool Schemas: Detailed definitions of available tools, including function name, purpose, required parameters, and expected outputs. These schemas enable the LLM to understand what tools are available and how to construct valid requests.

函数/工具模式（Function/Tool Schemas）： 可用工具的详细定义，包括函数名称、用途、所需参数和预期输出。 这些模式使 LLM 能够理解哪些工具可用以及如何构造有效的请求。

Function Execution Logic: Governs how and when tools are invoked based on the user’s intent and conversation context. This may include planner modules, routing mechanisms, or conditional flows that determine tool usage dynamically.

函数执行逻辑（Function Execution Logic）： 根据用户的意图和对话上下文来控制工具的调用方式和时间。 这可能包括规划器模块 (planner modules)、路由机制 (routing mechanisms) 或动态确定工具使用的条件流 (conditional flows)。

Message Handling System: Components that manage the conversational flow between user inputs, LLM responses, tool calls, and tool outputs.

消息处理系统（Message Handling System）： 管理用户输入、LLM 响应、工具调用和工具输出之间的对话流程的组件。

Tool Integration Framework: Infrastructure that connects the agent to various tools, whether they are simple functions or complex external services.

工具集成框架（Tool Integration Framework）： 将代理连接到各种工具的基础设施，无论它们是简单的函数还是复杂的外部服务。

Error Handling & Validation: Mechanisms to handle failures in tool execution, validate parameters, and manage unexpected responses.

错误处理与验证（Error Handling & Validation）： 处理工具执行失败、验证参数以及管理意外响应的机制。

State Management: Tracks conversation context, previous tool interactions, and persistent data to ensure consistency across multi-turn interactions.

状态管理（State Management）： 跟踪对话上下文、之前的工具交互和持久数据，以确保多轮交互的一致性。

An LLM model that supports function calling
支持函数调用的 LLM 模型
A schema containing function descriptions
包含函数描述的模式 (schema)
The code for each function described
每个描述的函数的代码

Initialize an LLM that supports function calling:

Not all models support function calling, so it's important to check that the LLM you are using does. Azure OpenAI supports function calling. We can start by initiating the Azure OpenAI client.

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

初始化支持函数调用的 LLM： 并非所有模型都支持函数调用，因此检查您使用的 LLM 是否支持非常重要。 Azure OpenAI 支持函数调用。 我们可以从启动 Azure OpenAI 客户端开始。 # 初始化 Azure OpenAI 客户端 client = AzureOpenAI( azure_endpoint = os.getenv("AZURE_AI_PROJECT_ENDPOINT"), api_key=os.getenv("AZURE_OPENAI_API_KEY"), api_version="2024-05-01-preview" )

Create a Function Schema:

Next we will define a JSON schema that contains the function name, description of what the function does, and the names and descriptions of the function parameters. We will then take this schema and pass it to the client created previously, along with the users request to find the time in San Francisco. What's important to note is that a tool call is what is returned, not the final answer to the question. As mentioned earlier, the LLM returns the name of the function it selected for the task, and the arguments that will be passed to it.

# 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"],
            },
        }
    }
]

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

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')])

.message messages.append(response_message) print("Model's response:") print(response_message) 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')])

The function code required to carry out the task:

Now that the LLM has chosen which function needs to be run the code that carries out the task needs to be implemented and executed. We can implement the code to get the current time in Python. We will also need to write the code to extract the name and arguments from the response_message to get the final result.

  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"})

# 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

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

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

from agent_framework import tool
from agent_framework.azure import AzureAIProjectAgentProvider
from azure.identity import AzureCliCredential

@tool
def get_current_time(location: str) -> str:
    """Get the current time for a given location"""
    ...

# Create the client
provider = AzureAIProjectAgentProvider(credential=AzureCliCredential())

# Create an agent and run with the tool
agent = await provider.create_agent(name="TimeAgent", instructions="Use available tools to answer questions.", tools=get_current_time)
response = await agent.run("What time is it?")

Automatic tool calling – no need to parse a tool call, invoke the tool, and handle the response; all of this is now done server-side
自动工具调用——无需解析工具调用、调用工具和处理响应； 所有这些现在都在服务器端完成
Securely managed data – instead of managing your own conversation state, you can rely on threads to store all the information you need
安全管理的数据——您可以依赖线程来存储您需要的所有信息，而不是管理您自己的对话状态
Out-of-the-box tools – Tools that you can use to interact with your data sources, such as Bing, Azure AI Search, and Azure Functions.
开箱即用的工具——您可以用来与您的数据源交互的工具，例如 Bing、Azure AI 搜索和 Azure Functions。

Knowledge Tools:

• Grounding with Bing Search
知识工具： 使用 Bing 搜索进行基础化 (Grounding)
File Search
文件搜索
Azure AI Search
Azure AI 搜索

Action Tools:

• Function Calling
行动工具： 函数调用
Code Interpreter
代码解释器
OpenAPI defined tools
OpenAPI 定义的工具 (OpenAPI defined tools)
Azure Functions
Azure Functions (Azure Functions)

import os
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from fetch_sales_data_functions import fetch_sales_data_using_sqlite_query # fetch_sales_data_using_sqlite_query function which can be found in a fetch_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 toolset
toolset = ToolSet()

# 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.add(fetch_data_function)

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

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

Introduction

This lesson will cover

Understand Agentic RAG: Learn about the emerging paradigm in AI where large language models (LLMs) autonomously plan their next steps while pulling information from external data sources.
了解 Agentic RAG：了解 AI 中新兴的范例，即大型语言模型 (LLM) 在从外部数据源提取信息的同时自主规划其后续步骤。
Grasp Iterative Maker-Checker Style: Comprehend the loop of iterative calls to the LLM, interspersed with tool or function calls and structured outputs, designed to improve correctness and handle malformed queries.
掌握迭代的 Maker-Checker 风格：理解对 LLM 的迭代调用循环，穿插着工具或函数调用以及结构化输出，旨在提高正确性并处理格式错误的查询。
Explore Practical Applications: Identify scenarios where Agentic RAG shines, such as correctness-first environments, complex database interactions, and extended workflows.
探索实际应用：确定 Agentic RAG 发光的情景，例如以正确性为先的环境、复杂的数据库交互和扩展的工作流程。

Learning Goals

After completing this lesson, you will know how to/understand:

Understanding Agentic RAG: Learn about the emerging paradigm in AI where large language models (LLMs) autonomously plan their next steps while pulling information from external data sources.
了解 Agentic RAG：了解 AI 中新兴的范例，即大型语言模型 (LLM) 在从外部数据源提取信息的同时自主规划其后续步骤。
Iterative Maker-Checker Style: Grasp the concept of a loop of iterative calls to the LLM, interspersed with tool or function calls and structured outputs, designed to improve correctness and handle malformed queries.
迭代的 Maker-Checker 风格：掌握对 LLM 的迭代调用循环的概念，穿插着工具或函数调用以及结构化输出，旨在提高正确性并处理格式错误的查询。
Owning the Reasoning Process: Comprehend the system's ability to own its reasoning process, making decisions on how to approach problems without relying on pre-defined paths.
拥有推理过程：理解系统拥有其推理过程的能力，在不依赖预定义路径的情况下，决定如何处理问题。
Workflow: Understand how an agentic model independently decides to retrieve market trend reports, identify competitor data, correlate internal sales metrics, synthesize findings, and evaluate the strategy.
工作流程：了解 Agentic 模型如何独立决定检索市场趋势报告、识别竞争对手数据、关联内部销售指标、综合调查结果以及评估策略。
Iterative Loops, Tool Integration, and Memory: Learn about the system's reliance on a looped interaction pattern, maintaining state and memory across steps to avoid repetitive loops and make informed decisions.
迭代循环、工具集成和记忆：了解系统对循环交互模式的依赖，跨步骤维护状态和记忆，以避免重复循环并做出明智的决策。
Handling Failure Modes and Self-Correction: Explore the system's robust self-correction mechanisms, including iterating and re-querying, using diagnostic tools, and falling back on human oversight.
处理失败模式和自我纠正：探索系统强大的自我纠正机制，包括迭代和重新查询、使用诊断工具以及退回到人工监督。
Boundaries of Agency: Understand the limitations of Agentic RAG, focusing on domain-specific autonomy, infrastructure dependence, and respect for guardrails.
Agency 的界限：了解 Agentic RAG 的局限性，重点关注特定领域的自主性、基础设施依赖性以及对护栏的尊重。
Practical Use Cases and Value: Identify scenarios where Agentic RAG shines, such as correctness-first environments, complex database interactions, and extended workflows.
实际用例和价值：确定 Agentic RAG 发光的情景，例如以正确性为先的环境、复杂的数据库交互和扩展的工作流程。
Governance, Transparency, and Trust: Learn about the importance of governance and transparency, including explainable reasoning, bias control, and human oversight.
治理、透明度和信任：了解治理和透明度的重要性，包括可解释的推理、偏差控制和人工监督。

Retrieve current market trend reports using Bing Web Grounding
使用 Bing Web Grounding (Bing Web Grounding) 检索当前市场趋势报告
Identify relevant competitor data using Azure AI Search.
使用 Azure AI Search (Azure AI Search) 识别相关的竞争对手数据。
Correlate historical internal sales metrics using Azure SQL Database.
使用 Azure SQL Database (Azure SQL Database) 关联历史内部销售指标。
Synthesize the findings into a cohesive strategy orchestrated via Azure OpenAI Service.
通过 Azure OpenAI Service (Azure OpenAI Service) 将调查结果综合成一个有凝聚力的策略。
Evaluate the strategy for gaps or inconsistencies, prompting another round of retrieval if necessary. All of these steps—refining queries, choosing sources, iterating until “happy” with the answer—are decided by the model, not pre-scripted by a human.
评估该策略是否存在差距或不一致之处，并在必要时提示进行另一轮检索。 所有这些步骤——改进查询、选择来源、迭代直到对答案“满意”——都由模型决定，而不是由人工预先编写脚本。

Initial Call: The user’s goal (aka. user prompt) is presented to the LLM.
初始调用 (Initial Call)：用户的目标（又称用户提示 (user prompt)）被提交给 LLM。
Tool Invocation: If the model identifies missing information or ambiguous instructions, it selects a tool or retrieval method—like a vector database query (e.g. Azure AI Search Hybrid search over private data) or a structured SQL call—to gather more context.
工具调用 (Tool Invocation)：如果模型识别出缺失的信息或模糊的指令，它会选择一种工具或检索方法——例如向量数据库查询 (vector database query) （例如，在私有数据上进行 Azure AI 搜索混合搜索 (Azure AI Search Hybrid search)）或结构化的 SQL 调用——以收集更多上下文。
Assessment & Refinement: After reviewing the returned data, the model decides whether the information suffices. If not, it refines the query, tries a different tool, or adjusts its approach.
评估与优化 (Assessment & Refinement)：在审查返回的数据后，模型会决定信息是否足够。如果不足够，它会优化查询、尝试不同的工具或调整其方法。
Repeat Until Satisfied: This cycle continues until the model determines that it has enough clarity and evidence to deliver a final, well-reasoned response.
重复直到满意 (Repeat Until Satisfied)：这个循环会持续进行，直到模型确定它有足够的清晰度和证据来提供最终的、经过充分论证的回复。
Memory & State: Because the system maintains state and memory across steps, it can recall previous attempts and their outcomes, avoiding repetitive loops and making more informed decisions as it proceeds.
记忆与状态 (Memory & State)：由于系统在各个步骤中保持状态和记忆，它可以回忆起之前的尝试及其结果，避免重复循环，并在进行过程中做出更明智的决策。

Iterate and Re-Query: Instead of returning low-value responses, the model attempts new search strategies, rewrites database queries, or looks at alternative data sets.
迭代和重新查询 (Iterate and Re-Query)：模型不是返回低价值的回复，而是尝试新的搜索策略，重写数据库查询，或查看替代数据集。
Use Diagnostic Tools: The system may invoke additional functions designed to help it debug its reasoning steps or confirm the correctness of retrieved data. Tools like Azure AI Tracing will be important to enable robust observability and monitoring.
使用诊断工具 (Use Diagnostic Tools)：系统可以调用额外的函数，这些函数旨在帮助它调试其推理步骤或确认检索数据的正确性。像 Azure AI Tracing 这样的工具对于实现强大的可观察性和监控非常重要。
Fallback on Human Oversight: For high-stakes or repeatedly failing scenarios, the model might flag uncertainty and request human guidance. Once the human provides corrective feedback, the model can incorporate that lesson going forward.
依赖人工监督 (Fallback on Human Oversight)：对于高风险或反复失败的场景，模型可能会标记不确定性并请求人工指导。一旦人类提供纠正性反馈，模型就可以在以后纳入该经验。

Domain-Specific Autonomy: Agentic RAG systems are focused on achieving user-defined goals within a known domain, employing strategies like query rewriting or tool selection to improve outcomes.
领域特定自主性 (Domain-Specific Autonomy)：代理 RAG (Agentic RAG) 系统专注于在已知领域内实现用户定义的目标，采用诸如查询重写或工具选择之类的策略来改善结果。
Infrastructure-Dependent: The system’s capabilities hinge on the tools and data integrated by developers. It can’t surpass these boundaries without human intervention.
依赖于基础设施 (Infrastructure-Dependent)：系统的能力取决于开发者集成的工具和数据。没有人工干预，它无法超越这些边界。
Respect for Guardrails: Ethical guidelines, compliance rules, and business policies remain very important. The agent’s freedom is always constrained by safety measures and oversight mechanisms (hopefully?)
尊重护栏 (Respect for Guardrails)：道德准则、合规规则和业务政策仍然非常重要。代理的自由始终受到安全措施和监督机制的约束（希望如此？）。

Correctness-First Environments: In compliance checks, regulatory analysis, or legal research, the agentic model can repeatedly verify facts, consult multiple sources, and rewrite queries until it produces a thoroughly vetted answer.
正确性优先的环境 (Correctness-First Environments)：在合规性检查、法规分析或法律研究中，代理模型可以反复验证事实、查阅多个来源并重写查询，直到生成一个经过彻底审查的答案。
Complex Database Interactions: When dealing with structured data where queries might often fail or need adjustment, the system can autonomously refine its queries using Azure SQL or Microsoft Fabric OneLake, ensuring the final retrieval aligns with the user’s intent.
复杂的数据库交互 (Complex Database Interactions)：在处理结构化数据时，查询可能经常失败或需要调整，系统可以使用 Azure SQL 或 Microsoft Fabric OneLake 自主地优化其查询，确保最终检索与用户的意图一致。
Extended Workflows: Longer-running sessions might evolve as new information surfaces. Agentic RAG can continuously incorporate new data, shifting strategies as it learns more about the problem space.
扩展的工作流程 (Extended Workflows)：随着新信息的出现，长时间运行的会话可能会演变。 代理 RAG (Agentic RAG) 可以不断地整合新数据，随着对问题空间的了解越来越多，而改变策略。

Explainable Reasoning: The model can provide an audit trail of the queries it made, the sources it consulted, and the reasoning steps it took to reach its conclusion. Tools like Azure AI Content Safety and Azure AI Tracing / GenAIOps can help maintain transparency and mitigate risks.
可解释的推理 (Explainable Reasoning)：模型可以提供一份审计跟踪，记录它进行的查询、它查阅的来源以及它为得出结论而采取的推理步骤。 Azure AI Content Safety 和 Azure AI Tracing / GenAIOps 等工具可以帮助保持透明度并降低风险。
Bias Control and Balanced Retrieval: Developers can tune retrieval strategies to ensure balanced, representative data sources are considered, and regularly audit outputs to detect bias or skewed patterns using custom models for advanced data science organizations using Azure Machine Learning.
偏差控制和平衡检索 (Bias Control and Balanced Retrieval)：开发人员可以调整检索策略，以确保考虑平衡的、具有代表性的数据源，并定期审核输出，以使用 Azure Machine Learning 的高级数据科学组织的定制模型检测偏差或倾斜模式。
Human Oversight and Compliance: For sensitive tasks, human review remains essential. Agentic RAG doesn’t replace human judgment in high-stakes decisions—it augments it by delivering more thoroughly vetted options.
人工监督和合规性 (Human Oversight and Compliance)：对于敏感任务，人工审查仍然至关重要。 代理 RAG (Agentic RAG) 不会取代高风险决策中的人工判断——它通过提供更彻底审查的选项来增强它。

Conclusion

Introduction

This lesson will cover:

How to build and deploy safe and effective AI Agents
如何构建和部署安全有效的 AI 代理
Important security considerations when developing AI Agents.
开发 AI 代理时重要的安全注意事项。
How to maintain data and user privacy when developing AI Agents.
开发 AI 代理时如何维护数据和用户隐私。

Learning Goals

After completing this lesson, you will know how to:

Identify and mitigate risks when creating AI Agents.
识别并缓解创建人工智能代理（AI Agents）时的风险。
Implement security measures to ensure that data and access are properly managed.
实施安全措施，确保数据和访问得到妥善管理。
Create AI Agents that maintain data privacy and provide a quality user experience.
创建维护数据隐私并提供高质量用户体验的人工智能代理（AI Agents）。

You are an expert at creating AI agent assistants. 
You will be provided a company name, role, responsibilities 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 responsibilities of the AI assistant. 

You are a travel agent for Contoso Travel 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.  

**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.

import os
from agent_framework.azure import AzureAIProjectAgentProvider
from azure.identity import AzureCliCredential

# Create the provider with human-in-the-loop approval
provider = AzureAIProjectAgentProvider(
    credential=AzureCliCredential(),
)

# Create the agent with a human approval step
response = provider.create_response(
    input="Write a 4-line poem about the ocean.",
    instructions="You are a helpful assistant. Ask for user approval before finalizing.",
)

# The user can review and approve the response
print(response.output_text)
user_input = input("Do you approve? (APPROVE/REJECT): ")
if user_input == "APPROVE":
    print("Response approved.")
else:
    print("Response rejected. Revising...")

Introduction

Defining a clear overall goal and breaking a complex task into manageable tasks.
定义清晰的总体目标，并将复杂的任务分解为可管理的任务。
Leveraging structured output for more reliable and machine-readable responses.
利用结构化输出（structured output）来获得更可靠和机器可读的响应。
Applying an event-driven approach to handle dynamic tasks and unexpected inputs.
应用事件驱动（event-driven）方法来处理动态任务和意外输入。

Learning Goals

Identify and set an overall goal for an AI agent, ensuring it clearly knows what needs to be achieved.
识别并设定AI代理的总体目标，确保它清楚地知道需要实现什么。
Decompose a complex task into manageable subtasks and organize them into a logical sequence.
将复杂的任务分解为可管理的子任务，并将它们组织成一个逻辑序列。
Equip agents with the right tools (e.g., search tools or data analytics tools), decide when and how they are used, and handle unexpected situations that arise.
为代理配备正确的工具（例如，搜索工具或数据分析工具），决定何时以及如何使用它们，并处理出现的意外情况。
Evaluate subtask outcomes, measure performance, and iterate on actions to improve the final output.
评估子任务的结果，衡量性能，并迭代操作以改进最终输出。

"Generate a 3-day travel itinerary."

Flight Booking
航班预订（Flight Booking）
Hotel Booking
酒店预订（Hotel Booking）
Car Rental
租车（Car Rental）
Personalization
个性化（Personalization）

from pydantic import BaseModel
from enum import Enum
from typing import List, Optional, Union
import json
import os
from typing import Optional
from pprint import pprint
from agent_framework.azure import AzureAIProjectAgentProvider
from azure.identity import AzureCliCredential

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

provider = AzureAIProjectAgentProvider(credential=AzureCliCredential())

# Define the user message
system_prompt = """You are a planner agent.
    Your job is to decide which agents to run based on the user's request.
    Provide your response in JSON format with the following structure:
{'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.'}
    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"""

user_message = "Create a travel plan for a family of 2 kids from Singapore to Melbourne"

response = client.create_response(input=user_message, instructions=system_prompt)

response_content = response.output_text
pprint(json.loads(response_content))

Receives the Hotel Plan: The planner takes the user’s message and, based on a system prompt (including available agent details), generates a structured travel plan.
接收酒店计划：规划器接收用户的消息，并根据系统提示（包括可用的代理详细信息）生成结构化的旅行计划。
Lists Agents and Their Tools: The agent registry holds a list of agents (e.g., for flight, hotel, car rental, and activities) along with the functions or tools they offer.
列出代理及其工具：代理注册表（agent registry）保存代理列表（例如，用于航班、酒店、汽车租赁和活动）以及它们提供的功能或工具。
Routes the Plan to the Respective Agents: Depending on the number of subtasks, the planner either sends the message directly to a dedicated agent (for single-task scenarios) or coordinates via a group chat manager for multi-agent collaboration.
将计划路由到相应的代理：根据子任务的数量，规划器可以直接将消息发送到专用代理（用于单任务场景），或者通过群聊管理器（group chat manager）协调多代理协作。
Summarizes the Outcome: Finally, the planner summarizes the generated plan for clarity. The following Python code sample illustrates these steps:
总结结果：最后，规划器总结生成的计划以使其清晰。 以下 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 agent_framework.azure import AzureAIProjectAgentProvider
from azure.identity import AzureCliCredential

# Create the client

provider = AzureAIProjectAgentProvider(credential=AzureCliCredential())

from pprint import pprint

# Define the user message

system_prompt = """You are a planner agent.
    Your job is to decide which agents to run based on the user's request.
    Below are the available agents specialized 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"""

user_message = "Create a travel plan for a family of 2 kids from Singapore to Melbourne"

response = client.create_response(input=user_message, instructions=system_prompt)

response_content = response.output_text

# Print the response content after loading it as JSON

pprint(json.loads(response_content))

{
    "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."
        }
    ]
}

from agent_framework.azure import AzureAIProjectAgentProvider
from azure.identity import AzureCliCredential
#.. same as previous code and pass on the user history, current plan

system_prompt = """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 specialized 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"""

user_message = "Create a travel plan for a family of 2 kids from Singapore to Melbourne"

response = client.create_response(
    input=user_message,
    instructions=system_prompt,
    context=f"Previous travel plan - {TravelPlan}",
)
# .. re-plan and send the tasks to respective agents

Summary

Introduction

What are the scenarios where multi-agents are applicable to?
多代理 (multi-agents) 适用于哪些场景？
What are the advantages of using multi-agents over just one singular agent doing multiple tasks?
与仅由一个单一代理 (agent) 执行多个任务相比，使用多代理 (multi-agents) 有哪些优势？
What are the building blocks of implementing the multi-agent design pattern?
实现多代理 (multi-agent) 设计模式 (design pattern) 的构建块是什么？
How do we have visibility to how the multiple agents are interacting with each other?
我们如何了解多个代理 (agents) 之间的交互方式？

Learning Goals

Identify scenarios where multi-agents are applicable
识别多代理 (multi-agents) 适用的场景。
Recognize the advantages of using multi-agents over a singular agent.
认识到使用多代理 (multi-agents) 而不是单一代理 (agent) 的优势。
Comprehend the building blocks of implementing the multi-agent design pattern.
理解实现多代理 (multi-agent) 设计模式 (design pattern) 的构建块。

Large workloads: Large workloads can be divided into smaller tasks and assigned to different agents, allowing for parallel processing and faster completion. An example of this is in the case of a large data processing task.
大工作量 (Large workloads)： 大工作量 (Large workloads) 可以分成更小的任务并分配给不同的代理 (agents)，从而实现并行处理和更快的完成速度。这方面的一个例子是在大型数据处理任务的情况下。
Complex tasks: Complex tasks, like large workloads, can be broken down into smaller subtasks and assigned to different agents, each specializing in a specific aspect of the task. A good example of this is in the case of autonomous vehicles where different agents manage navigation, obstacle detection, and communication with other vehicles.
复杂任务 (Complex tasks)： 像大工作量 (large workloads) 一样，复杂任务 (Complex tasks) 可以分解为更小的子任务并分配给不同的代理 (agents)，每个代理 (agent) 专门负责任务的特定方面。这方面的一个很好的例子是在自动驾驶汽车的情况下，不同的代理 (agents) 管理导航、障碍物检测以及与其他车辆的通信。
Diverse expertise: Different agents can have diverse expertise, allowing them to handle different aspects of a task more effectively than a single agent. For this case, a good example is in the case of healthcare where agents can manage diagnostics, treatment plans, and patient monitoring.
多样化的专业知识 (Diverse expertise)： 不同的代理 (agents) 可以拥有多样化的专业知识 (expertise)，使他们能够比单个代理 (agent) 更有效地处理任务的不同方面。对于这种情况，一个很好的例子是在医疗保健领域，代理 (agents) 可以管理诊断、治疗计划和患者监测。

Specialization: Each agent can be specialized for a specific task. Lack of specialization in a single agent means you have an agent that can do everything but might get confused on what to do when faced with a complex task. It might for example end up doing a task that it is not best suited for.
专业化 (Specialization)： 每个代理 (agent) 都可以专门负责特定任务。单一代理 (agent) 缺乏专业化意味着你有一个可以做所有事情的代理 (agent)，但当面临复杂任务时可能会对该做什么感到困惑。例如，它最终可能会执行一项它不最适合的任务。
Scalability: It is easier to scale systems by adding more agents rather than overloading a single agent.
可扩展性 (Scalability)： 通过添加更多代理 (agents) 而不是超载单个代理 (agent) 来扩展系统更容易。
Fault Tolerance: If one agent fails, others can continue functioning, ensuring system reliability.
容错性 (Fault Tolerance)： 如果一个代理 (agent) 失败，其他代理 (agents) 可以继续运行，从而确保系统可靠性。

Agent Communication: Agents for finding flights, booking hotels, and rental cars need to communicate and share information about the user's preferences and constraints. You need to decide on the protocols and methods for this communication. What this means concretely is that the agent for finding flights needs to communicate with the agent for booking hotels to ensure that the hotel is booked for the same dates as the flight. That means that the agents need to share information about the user's travel dates, meaning that you need to decide which agents are sharing info and how they are sharing info.
代理 (Agent) 通信： 用于寻找航班、预订酒店和租车的代理 (agents) 需要沟通并分享有关用户偏好和约束的信息。您需要决定此通信的协议和方法。具体而言，这意味着寻找航班的代理 (agent) 需要与预订酒店的代理 (agent) 进行通信，以确保酒店预订的日期与航班相同。这意味着代理 (agents) 需要分享有关用户旅行日期的信息，这意味着您需要决定哪些代理 (agents) 正在分享信息以及他们如何分享信息。
Coordination Mechanisms: Agents need to coordinate their actions to ensure that the user's preferences and constraints are met. A user preference could be that they want a hotel close to the airport whereas a constraint could be that rental cars are only available at the airport. This means that the agent for booking hotels needs to coordinate with the agent for booking rental cars to ensure that the user's preferences and constraints are met. This means that you need to decide how the agents are coordinating their actions.
协调机制 (Coordination Mechanisms)： 代理 (Agents) 需要协调他们的行动，以确保满足用户的偏好和约束。用户的偏好可能是他们想要一家靠近机场的酒店，而约束可能是只有在机场才能租到车。这意味着预订酒店的代理 (agent) 需要与预订租车的代理 (agent) 协调，以确保满足用户的偏好和约束。这意味着您需要决定代理 (agents) 如何协调他们的行动。
Agent Architecture: Agents need to have the internal structure to make decisions and learn from their interactions with the user. This means that the agent for finding flights needs to have the internal structure to make decisions about which flights to recommend to the user. This means that you need to decide how the agents are making decisions and learning from their interactions with the user. Examples of how an agent learns and improves could be that the agent for finding flights could use a machine learning model to recommend flights to the user based on their past preferences.
代理 (Agent) 架构 (Architecture)： 代理 (Agents) 需要有内部结构来做出决策并从与用户的互动中学习。这意味着寻找航班的代理 (agent) 需要有内部结构来决定向用户推荐哪些航班。这意味着您需要决定代理 (agents) 如何做出决策并从与用户的互动中学习。代理 (agent) 学习和改进方式的例子可能是，寻找航班的代理 (agent) 可以使用机器学习模型根据用户过去的偏好向用户推荐航班。
Visibility into Multi-Agent Interactions: You need to have visibility into how the multiple agents are interacting with each other. This means that you need to have tools and techniques for tracking agent activities and interactions. This could be in the form of logging and monitoring tools, visualization tools, and performance metrics.
多代理 (Multi-Agent) 交互的可视性 (Visibility)： 您需要了解多个代理 (agents) 如何相互交互。这意味着您需要拥有用于跟踪代理 (agent) 活动和交互的工具和技术。这可以是日志记录和监控工具、可视化工具和性能指标的形式。
Multi-Agent Patterns: There are different patterns for implementing multi-agent systems, such as centralized, decentralized, and hybrid architectures. You need to decide on the pattern that best fits your use case.
多代理 (Multi-Agent) 模式 (Patterns)： 有不同的模式 (patterns) 用于实现多代理 (multi-agent) 系统，例如集中式、去中心化和混合架构。您需要决定最适合您用例的模式 (pattern)。
Human in the loop: In most cases, you will have a human in the loop and you need to instruct the agents when to ask for human intervention. This could be in the form of a user asking for a specific hotel or flight that the agents have not recommended or asking for confirmation before booking a flight or hotel.
人在环路 (Human in the loop)：在大多数情况下，您会需要让人参与到流程中，并且需要指示智能体何时请求人工干预。这可能表现为用户要求提供智能体未推荐的特定酒店或航班，或者在预订航班或酒店之前要求确认。

Logging and Monitoring Tools: You want to have logging done for each action taken by an agent. A log entry could store information on the agent that took the action, the action taken, the time the action was taken, and the outcome of the action. This information can then be used for debugging, optimizing and more.

日志记录和监控工具 (Logging and Monitoring Tools)：您需要为智能体采取的每个操作进行日志记录。一个日志条目可以存储有关采取行动的智能体、采取的行动、采取行动的时间以及行动结果的信息。然后，这些信息可以用于调试、优化等。

Visualization Tools: Visualization tools can help you see the interactions between agents in a more intuitive way. For example, you could have a graph that shows the flow of information between agents. This could help you identify bottlenecks, inefficiencies, and other issues in the system.

可视化工具 (Visualization Tools)：可视化工具可以帮助您以更直观的方式查看智能体之间的交互。例如，您可以拥有一个图表，显示智能体之间的信息流。这可以帮助您识别系统中的瓶颈、效率低下的问题和其他问题。

Performance Metrics: Performance metrics can help you track the effectiveness of the multi-agent system. For example, you could track the time taken to complete a task, the number of tasks completed per unit of time, and the accuracy of the recommendations made by the agents. This information can help you identify areas for improvement and optimize the system.

性能指标 (Performance Metrics)：性能指标可以帮助您跟踪多智能体系统的有效性。例如，您可以跟踪完成任务所花费的时间、单位时间内完成的任务数量以及智能体提出的建议的准确性。这些信息可以帮助您确定需要改进的领域并优化系统。

Industry expert:. One agent could be an expert in a specific industry.
行业专家 (Industry expert)：一个智能体可以是特定行业的专家。
Technical analysis: Another agent could be an expert in technical analysis.
技术分析 (Technical analysis)：另一个智能体可以是技术分析方面的专家。
Fundamental analysis: and another agent could be an expert in fundamental analysis. By collaborating, these agents can provide a more comprehensive recommendation to the user.
基本面分析 (Fundamental analysis)：另一个智能体可以是基本面分析方面的专家。通过协作，这些智能体可以为用户提供更全面的建议。

Customer agent: This agent represents the customer and is responsible for initiating the refund process.
客户智能体 (Customer agent)：此智能体代表客户，负责启动退款流程。
Seller agent: This agent represents the seller and is responsible for processing the refund.
卖家智能体 (Seller agent)：此智能体代表卖家，负责处理退款。
Payment agent: This agent represents the payment process and is responsible for refunding the customer's payment.
支付智能体 (Payment agent)：此智能体代表支付流程，负责退还客户的付款。
Resolution agent: This agent represents the resolution process and is responsible for resolving any issues that arise during the refund process.
解决智能体 (Resolution agent)：此智能体代表解决流程，负责解决退款流程中出现的任何问题。
Compliance agent: This agent represents the compliance process and is responsible for ensuring that the refund process complies with regulations and policies.
合规智能体 (Compliance agent)：此智能体代表合规流程，负责确保退款流程符合法规和政策。

Shipping agent: This agent represents the shipping process and is responsible for shipping the product back to the seller. This agent can be used both for the refund process and for general shipping of a product via a purchase for example.
运输智能体 (Shipping agent)：此智能体代表运输流程，负责将产品运回给卖家。例如，此智能体既可以用于退款流程，也可以用于通过购买进行产品的常规运输。
Feedback agent: This agent represents the feedback process and is responsible for collecting feedback from the customer. Feedback could be had at any time and not just during the refund process.
反馈智能体 (Feedback agent)：此智能体代表反馈流程，负责收集客户的反馈。反馈可以在任何时候进行，而不仅仅是在退款流程中。
Escalation agent: This agent represents the escalation process and is responsible for escalating issues to a higher level of support. You can use this type of agent for any process where you need to escalate an issue.
升级智能体 (Escalation agent)：此智能体代表升级流程，负责将问题升级到更高级别的支持。您可以将此类智能体用于任何需要升级问题的流程。
Notification agent: This agent represents the notification process and is responsible for sending notifications to the customer at various stages of the refund process.
通知智能体 (Notification agent)：此智能体代表通知流程，负责在退款流程的各个阶段向客户发送通知。
Analytics agent: This agent represents the analytics process and is responsible for analyzing data related to the refund process.
分析代理（Analytics agent）：该代理代表分析过程，负责分析与退款流程相关的数据。
Audit agent: This agent represents the audit process and is responsible for auditing the refund process to ensure that it is being carried out correctly.
审计代理（Audit agent）：该代理代表审计过程，负责审计退款流程，以确保其正确执行。
Reporting agent: This agent represents the reporting process and is responsible for generating reports on the refund process.
报告代理（Reporting agent）：该代理代表报告过程，负责生成关于退款流程的报告。
Knowledge agent: This agent represents the knowledge process and is responsible for maintaining a knowledge base of information related to the refund process. This agent could be knowledgeable both on refunds and other parts of your business.
知识代理（Knowledge agent）：该代理代表知识过程，负责维护与退款流程相关的信息知识库。该代理可以了解退款以及您业务的其他部分。
Security agent: This agent represents the security process and is responsible for ensuring the security of the refund process.
安全代理（Security agent）：该代理代表安全过程，负责确保退款流程的安全性。
Quality agent: This agent represents the quality process and is responsible for ensuring the quality of the refund process.
质量代理（Quality agent）：该代理代表质量过程，负责确保退款流程的质量。

A1: When you have a small workload and a simple task.
A1：当您的工作量很小且任务很简单时。
A2: When you have a large workload
A2：当您的工作量很大时。
A3: When you have a simple task.
A3：当您的任务很简单时。

Introduction

Learning Goals

Understand the implications of reasoning loops in agent definitions.
了解推理循环在代理定义中的含义。
Use planning and evaluation techniques to help self-correcting agents.
使用规划和评估技术来帮助自我纠正代理。
Create your own agents capable of manipulating code to accomplish tasks.
创建您自己的能够操纵代码以完成任务的代理。

Transparency: Ensuring that AI systems can explain their reasoning and decisions.
透明度（Transparency）：确保人工智能系统可以解释他们的推理和决策。
Reasoning: Enhancing the ability of AI systems to synthesize information and make sound decisions.
推理（Reasoning）：增强人工智能系统综合信息和做出合理决策的能力。
Adaptation: Allowing AI systems to adjust to new environments and changing conditions.
适应性（Adaptation）：允许人工智能系统适应新环境和不断变化的条件。
Perception: Improving the accuracy of AI systems in recognizing and interpreting data from their environment.
感知（Perception）：提高人工智能系统识别和解释来自环境的数据的准确性。

Noting that it made mistakes because it over-relied on user preferences from last time, so it modifies its decision-making strategy not just the final recommendation.
注意到它犯了错误，因为它过度依赖上次的用户偏好，因此它修改了其决策策略，而不仅仅是最终建议。（Noting that it made mistakes because it over-relied on user preferences from last time, so it modifies its decision-making strategy not just the final recommendation.）
Diagnosing patterns like, “Whenever I see the user mention ‘too crowded,’ I should not only remove certain attractions but also reflect that my method of picking ‘top attractions’ is flawed if I always rank by popularity.”
诊断模式，例如，“每当我看到用户提到‘太拥挤’时，我不但应该移除某些景点，还应该反思，如果我总是按受欢迎程度排名，那么我选择‘热门景点’的方法是有缺陷的。”

Self-Reflection: Agents can assess their own performance and identify areas for improvement.
自我反思 (Self-Reflection)：智能体可以评估自身的表现，并找出需要改进的地方。
Adaptability: Agents can modify their strategies based on past experiences and changing environments.
适应性 (Adaptability)：智能体可以根据过去的经验和不断变化的环境来调整其策略。
Error Correction: Agents can detect and correct errors autonomously, leading to more accurate outcomes.
错误纠正 (Error Correction)：智能体可以自主检测和纠正错误，从而获得更准确的结果。
Resource Management: Agents can optimize the use of resources, such as time and computational power, by planning and evaluating their actions.
资源管理 (Resource Management)：智能体可以通过规划和评估其行为来优化资源的使用，例如时间和计算能力。

Persona: The personality and characteristics of the agent, which define how it interacts with users.
角色 (Persona)：智能体的个性和特征，决定了它如何与用户互动。
Tools: The capabilities and functions that the agent can perform.
工具 (Tools)：智能体可以执行的能力和功能。
Skills: The knowledge and expertise that the agent possesses.
技能 (Skills)：智能体拥有的知识和专业技能。

Gather User Preferences: Ask the user about their travel dates, budget, interests (e.g., museums, cuisine, shopping), and any specific requirements.
收集用户偏好 (Gather User Preferences)：询问用户的旅行日期、预算、兴趣（例如，博物馆、美食、购物）以及任何特定要求。
Retrieve Information: Search for flight options, accommodations, attractions, and restaurants that match the user's preferences.
检索信息 (Retrieve Information)：搜索符合用户偏好的航班选项、住宿、景点和餐厅。
Generate Recommendations: Provide a personalized itinerary with flight details, hotel reservations, and suggested activities.
生成推荐 (Generate Recommendations)：提供包含航班详情、酒店预订和建议活动的个性化行程。
Adjust Based on Feedback: Ask the user for feedback on the recommendations and make necessary adjustments.
根据反馈进行调整 (Adjust Based on Feedback)：向用户征求对推荐的反馈并进行必要的调整。

Access to flight and hotel booking databases.
访问航班和酒店预订数据库。
Information on Parisian attractions and restaurants.
巴黎景点和餐厅的信息。
User feedback data from previous interactions.
来自之前互动用户的反馈数据。

Analyzing User Feedback: Travel Agent reviews user feedback to determine which recommendations were well-received and which were not. It adjusts its future suggestions accordingly.
分析用户反馈 (Analyzing User Feedback)：旅行社 (Travel Agent) 审查用户反馈，以确定哪些建议受到好评，哪些没有。它会相应地调整未来的建议。
Adaptability: If a user has previously mentioned a dislike for crowded places, Travel Agent will avoid recommending popular tourist spots during peak hours in the future.
适应性 (Adaptability)：如果用户之前提到过不喜欢拥挤的地方，旅行社 (Travel Agent) 将来会避免在高峰时段推荐热门旅游景点。
Error Correction: If Travel Agent made an error in a past booking, such as suggesting a hotel that was fully booked, it learns to check availability more rigorously before making recommendations.
错误纠正 (Error Correction)：如果旅行社 (Travel Agent) 在过去的预订中犯了错误，例如推荐了一家已经预订满的酒店，它会学会更严格地检查可用性，然后再提出建议。

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)

Self-Reflection: Agents can analyze their performance and identify areas for improvement.
自我反思 (Self-Reflection)：智能体可以分析其表现，并找出需要改进的地方。
Adaptability: Agents can modify strategies based on feedback and changing conditions.
适应性 (Adaptability)：智能体可以根据反馈和不断变化的环境来调整策略。
Error Correction: Agents can autonomously detect and correct mistakes.
错误纠正 (Error Correction)：智能体可以自主检测和纠正错误。
Resource Management: Agents can optimize resource usage, such as time and computational power.
资源管理 (Resource Management)：智能体可以优化资源的使用，例如时间和计算能力。

2. Planning in Agents

Current Task: Define the task clearly.
当前任务 (Current Task): 明确定义任务。
Steps to Complete the Task: Break down the task into manageable steps.
完成任务的步骤 (Steps to Complete the Task): 将任务分解为可管理的步骤。
Required Resources: Identify necessary resources.
所需资源 (Required Resources): 确定必要的资源。
Experience: Utilize past experiences to inform planning.
经验 (Experience): 利用过去的经验来指导规划。

Gather User Preferences

• Ask the user for details about their travel dates, budget, interests, and any specific requirements.
收集用户偏好 (Gather User Preferences) 询问用户关于他们的旅行日期、预算、兴趣和任何具体要求的详细信息。
Examples: "When are you planning to travel?" "What is your budget range?" "What activities do you enjoy on vacation?"
例子: “您计划何时旅行？”“您的预算范围是多少？”“您在度假时喜欢什么活动？”

Retrieve Information

• Search for relevant travel options based on user preferences.
检索信息 (Retrieve Information) 根据用户偏好搜索相关的旅行选项。
Flights: Look for available flights within the user's budget and preferred travel dates.
航班 (Flights): 在用户的预算和首选旅行日期内寻找可用的航班。
Accommodations: Find hotels or rental properties that match the user's preferences for location, price, and amenities.
住宿 (Accommodations): 寻找符合用户在位置、价格和设施方面偏好的酒店或租赁房产。
Attractions and Restaurants: Identify popular attractions, activities, and dining options that align with the user's interests.
景点和餐厅 (Attractions and Restaurants): 确定符合用户兴趣的热门景点、活动和餐饮选择。

Generate Recommendations

• Compile the retrieved information into a personalized itinerary.
生成推荐 (Generate Recommendations) 将检索到的信息编译成个性化的行程。
Provide details such as flight options, hotel reservations, and suggested activities, making sure to tailor the recommendations to the user's preferences.
提供诸如航班选项、酒店预订和建议的活动等详细信息，确保根据用户的偏好定制推荐。

Present Itinerary to User

• Share the proposed itinerary with the user for their review.
向用户展示行程 (Present Itinerary to User) 与用户分享建议的行程，供其审查。
Example: "Here's a suggested itinerary for your trip to Paris. It includes flight details, hotel bookings, and a list of recommended activities and restaurants. Let me know your thoughts!"
例子: “这是为您前往巴黎的旅行建议的行程。它包括航班详情、酒店预订以及推荐的活动和餐厅列表。请告诉我您的想法！”

Collect Feedback

• Ask the user for feedback on the proposed itinerary.
收集反馈 (Collect Feedback) 向用户询问对建议行程的反馈。
Examples: "Do you like the flight options?" "Is the hotel suitable for your needs?" "Are there any activities you would like to add or remove?"
例子: “您喜欢航班选项吗？”“这家酒店适合您的需求吗？”“您想添加或删除任何活动吗？”

Adjust Based on Feedback

• Modify the itinerary based on the user's feedback.
根据反馈进行调整 (Adjust Based on Feedback) 根据用户的反馈修改行程。
Make necessary changes to flight, accommodation, and activity recommendations to better match the user's preferences.
对航班、住宿和活动建议进行必要的更改，以更好地满足用户的偏好。

Final Confirmation

• Present the updated itinerary to the user for final confirmation.
最终确认 (Final Confirmation) 向用户展示更新后的行程，以进行最终确认。
Example: "I've made the adjustments based on your feedback. Here's the updated itinerary. Does everything look good to you?"
例子: “我根据您的反馈进行了调整。这是更新后的行程。一切看起来都好吗？”

Book and Confirm Reservations

• Once the user approves the itinerary, proceed with booking flights, accommodations, and any pre-planned activities.
预订和确认预订 (Book and Confirm Reservations) 一旦用户批准行程，继续预订航班、住宿和任何预先计划的活动。
Send confirmation details to the user.
将确认详情发送给用户。

Provide Ongoing Support

• Remain available to assist the user with any changes or additional requests before and during their trip.
提供持续支持 (Provide Ongoing Support) 在用户旅行之前和期间，随时帮助用户进行任何更改或提出其他要求。
Example: "If you need any further assistance during your trip, feel free to reach out to me anytime!"
例子: “如果您在旅途中需要任何进一步的帮助，请随时与我联系！”

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

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

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

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

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

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

3. Corrective RAG System

Prompting Technique: Using specific prompts to guide the agent in retrieving relevant information.
提示技术 (Prompting Technique): 使用特定的提示来指导智能体检索相关信息。
Tool: Implementing algorithms and mechanisms that enable the agent to evaluate the relevance of the retrieved information and generate accurate responses.
工具 (Tool): 实施算法和机制，使智能体能够评估检索到的信息的相关性并生成准确的响应。
Evaluation: Continuously assessing the agent's performance and making adjustments to improve its accuracy and efficiency.
评估 (Evaluation): 不断评估智能体的性能并进行调整，以提高其准确性和效率。

Prompting Technique: Formulating search queries based on the user's input.
提示技术（Prompting Technique）：根据用户的输入制定搜索查询。
Tool: Using natural language processing and machine learning algorithms to rank and filter search results.
工具（Tool）：使用自然语言处理和机器学习算法对搜索结果进行排序和过滤。
Evaluation: Analyzing user feedback to identify and correct inaccuracies in the retrieved information.
评估（Evaluation）：分析用户反馈，以识别和纠正检索到的信息中的不准确之处。

Prompting Technique: Using specific prompts to guide the agent in retrieving relevant information.
提示技术（Prompting Technique）：使用特定的提示来指导代理检索相关信息。
Tool: Implementing algorithms and mechanisms that enable the agent to evaluate the relevance of the retrieved information and generate accurate responses.
工具（Tool）：实施算法和机制，使代理能够评估检索到的信息的相关性并生成准确的响应。
Evaluation: Continuously assessing the agent's performance and making adjustments to improve its accuracy and efficiency.
评估（Evaluation）：不断评估代理的性能，并进行调整以提高其准确性和效率。

Initial User Interaction

• Travel Agent gathers initial preferences from the user, such as destination, travel dates, budget, and interests.

初始用户交互 旅游代理从用户那里收集初始偏好，例如目的地、旅行日期、预算和兴趣。

Example:

preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}

示例： preferences = { "destination": "Paris", "dates": "2025-04-01 to 2025-04-10", "budget": "moderate", "interests": ["museums", "cuisine"] }

Retrieval of Information

• Travel Agent retrieves information about flights, accommodations, attractions, and restaurants based on user preferences.

信息检索 旅游代理根据用户偏好检索有关航班、住宿、景点和餐厅的信息。

Example:

flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)

示例： flights = search_flights(preferences) hotels = search_hotels(preferences) attractions = search_attractions(preferences)

Generating Initial Recommendations

• Travel Agent uses the retrieved information to generate a personalized itinerary.

生成初始建议 旅游代理使用检索到的信息生成个性化的行程。

Example:

itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)

示例： itinerary = create_itinerary(flights, hotels, attractions) print("Suggested Itinerary:", itinerary)

Collecting User Feedback

• Travel Agent asks the user for feedback on the initial recommendations.

收集用户反馈 旅游代理要求用户对初始建议提供反馈。

Example:

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

示例： feedback = { "liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"] }

Corrective RAG Process

• Prompting Technique: Travel Agent formulates new search queries based on user feedback.

  • Example:

    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    

  纠正性RAG (Corrective RAG) 流程 提示技术（Prompting Technique）：旅游代理根据用户反馈制定新的搜索查询。 示例： if "disliked" in feedback: preferences["avoid"] = feedback["disliked"]

Tool: Travel Agent uses algorithms to rank and filter new search results, emphasizing the relevance based on user feedback.

• Example:

  new_attractions = search_attractions(preferences)
  new_itinerary = create_itinerary(flights, hotels, new_attractions)
  print("Updated Itinerary:", new_itinerary)
  

工具（Tool）：旅游代理使用算法对新的搜索结果进行排序和过滤，强调基于用户反馈的相关性。 示例： new_attractions = search_attractions(preferences) new_itinerary = create_itinerary(flights, hotels, new_attractions) print("Updated Itinerary:", new_itinerary)

Evaluation: Travel Agent continuously assesses the relevance and accuracy of its recommendations by analyzing user feedback and making necessary adjustments.

• Example:

  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)
  

评估（Evaluation）：旅游代理通过分析用户反馈并进行必要的调整，不断评估其建议的相关性和准确性。 示例： 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)

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)

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

Steps

Define the client's preferences and budget.
定义客户的偏好和预算。
Bootstrap the initial plan based on these preferences.
根据这些偏好启动初始计划。
Iterate to refine the plan, optimizing for the client's satisfaction.
迭代以改进计划，优化客户的满意度。

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)

Initialization (__init__ method): The TravelAgent class is initialized with a list of potential destinations, each having attributes like name, cost, and activity type.

初始化 (Initialization) (``__init__`` 方法 (``__init__`` method)): ``TravelAgent`` 类 (``TravelAgent`` class) 通过一个潜在目的地的列表进行初始化，每个目的地都具有诸如名称 (name)、费用 (cost) 和活动类型 (activity type) 等属性。

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.

启动计划 (Bootstrapping the Plan) (``bootstrap_plan`` 方法 (``bootstrap_plan`` method)): 此方法根据客户的偏好和预算创建初始旅行计划。它遍历目的地列表，并将与客户偏好匹配并在预算范围内的目的地添加到计划中。

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

匹配偏好 (Matching Preferences) (``match_preferences`` 方法 (``match_preferences`` method)): 此方法检查目的地是否与客户的偏好相符。

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.

迭代计划 (Iterating the Plan) (``iterate_plan`` 方法 (``iterate_plan`` method)): 此方法通过尝试用更好的匹配项替换计划中的每个目的地来优化初始计划，同时考虑客户的偏好和预算约束。

Calculating Cost (calculate_cost method): This method calculates the total cost of the current plan, including a potential new destination.

计算成本 (Calculating Cost) (``calculate_cost`` 方法 (``calculate_cost`` method)): 此方法计算当前计划的总成本，包括潜在的新目的地。

Initial Plan: The travel agent creates an initial plan based on the client's preferences for sightseeing and a budget of $2000.
初始计划 (Initial Plan): 旅行社根据客户对观光的偏好和 2000 美元的预算创建初始计划。
Refined Plan: The travel agent iterates the plan, optimizing for the client's preferences and budget.
优化计划 (Refined Plan): 旅行社迭代该计划，针对客户的偏好和预算进行优化。

Collect user preferences.
收集用户偏好 (Collect user preferences)。
Retrieve a list of potential travel destinations.
检索潜在旅行目的地列表 (Retrieve a list of potential travel destinations)。
Use the LLM to re-rank and score the destinations based on user preferences.
使用 LLM 根据用户偏好重新排序和评分目的地 (Use the LLM to re-rank and score the destinations based on user preferences)。

You need to have an Azure subscription.
您需要拥有 Azure 订阅 (You need to have an Azure subscription)。
Create an Azure OpenAI resource and get your API key.
创建 Azure OpenAI 资源并获取您的 API 密钥 (Create an Azure OpenAI resource and get your API key)。

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)

Initialization: The TravelAgent class is initialized with a list of potential travel destinations, each having attributes like name and description.

初始化 (Initialization): ``TravelAgent`` 类 (``TravelAgent`` class) 使用潜在旅行目的地的列表进行初始化，每个目的地都具有诸如名称 (name) 和描述 (description) 等属性。

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.

获取推荐 (Getting Recommendations) (``get_recommendations`` 方法 (``get_recommendations`` method)): 此方法根据用户的偏好为 Azure OpenAI 服务生成提示，并向 Azure OpenAI API 发出 HTTP POST 请求，以获取重新排序和评分的目的地。

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.

生成提示 (Generating Prompt) (``generate_prompt`` 方法 (``generate_prompt`` method)): 此方法为 Azure OpenAI 构建提示，包括用户的偏好和目的地列表。 该提示指导模型根据提供的偏好重新排序和评分目的地。

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.

API 调用 (API Call): requests 库用于向 Azure OpenAI API 端点发出 HTTP POST 请求。 响应包含重新排序和评分的目的地。

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.

示例用法 (Example Usage): 旅行社收集用户偏好（例如，对观光和多元文化的兴趣），并使用 Azure OpenAI 服务获取旅行目的地的重新排序和评分的推荐。

What is it?

As a prompting technique, RAG involves formulating specific queries or prompts to guide the retrieval of relevant information from a large corpus or database. This information is then used to generate responses or actions.
作为一种提示技术，RAG 涉及制定特定的查询或提示，以引导从大型语料库或数据库中检索相关信息。然后，这些信息被用于生成响应或行动。

How it works:

Formulate Prompts: Create well-structured prompts or queries based on the task at hand or the user's input.
制定提示 (Formulate Prompts)： 基于手头的任务或用户的输入，创建结构良好的提示或查询。
Retrieve Information: Use the prompts to search for relevant data from a pre-existing knowledge base or dataset.
检索信息 (Retrieve Information)： 使用提示从预先存在的知识库或数据集中搜索相关数据。
Generate Response: Combine the retrieved information with generative AI models to produce a comprehensive and coherent response.
生成响应 (Generate Response)： 将检索到的信息与生成式 AI 模型相结合，以产生全面且连贯的响应。

Example in Travel Agent:

• User Input: "I want to visit museums in Paris."
Prompt: "Find top museums in Paris."
提示： "查找巴黎的顶级博物馆。"
Retrieved Information: Details about Louvre Museum, Musée d'Orsay, etc.
检索到的信息： 关于卢浮宫、奥赛博物馆等的详细信息。
• Generated Response: "Here are some top museums in Paris: Louvre Museum, Musée d'Orsay, and Centre Pompidou."

As a tool, RAG is an integrated system that automates the retrieval and generation process, making it easier for developers to implement complex AI functionalities without manually crafting prompts for each query.
作为一个工具，RAG 是一个集成的系统，可以自动执行检索和生成过程，使开发人员更容易实现复杂的 AI 功能，而无需为每个查询手动制作提示。

Integration: Embed RAG within the AI agent's architecture, allowing it to automatically handle the retrieval and generation tasks.
集成 (Integration)： 将 RAG 嵌入到 AI 代理的架构中，使其能够自动处理检索和生成任务。
Automation: The tool manages the entire process, from receiving user input to generating the final response, without requiring explicit prompts for each step.
自动化 (Automation)： 该工具管理整个过程，从接收用户输入到生成最终响应，而无需为每个步骤提供显式提示。
Efficiency: Enhances the agent's performance by streamlining the retrieval and generation process, enabling quicker and more accurate responses.
效率 (Efficiency)： 通过简化检索和生成过程来提高代理的性能，从而实现更快、更准确的响应。

User Input: "I want to visit museums in Paris."
用户输入： "我想参观巴黎的博物馆。"
RAG Tool: Automatically retrieves information about museums and generates a response.
RAG 工具： 自动检索关于博物馆的信息并生成响应。
Generated Response: "Here are some top museums in Paris: Louvre Museum, Musée d'Orsay, and Centre Pompidou."
生成的响应： "以下是一些巴黎的顶级博物馆：卢浮宫、奥赛博物馆和蓬皮杜艺术中心。"

def search_museums_in_paris():
    prompt = "Find top museums in Paris"
    search_results = search_web(prompt)
    return search_results

museums = search_museums_in_paris()
print("Top Museums in Paris:", museums)

class Travel_Agent:
    def __init__(self):
        self.rag_tool = RAGTool()

    def get_museums_in_paris(self):
        user_input = "I want to visit museums in Paris."
        response = self.rag_tool.retrieve_and_generate(user_input)
        return response

travel_agent = Travel_Agent()
museums = travel_agent.get_museums_in_paris()
print("Top Museums in Paris:", museums)

Context Awareness:

• The agent must understand the context of the user's query to retrieve and generate relevant information.
上下文感知 (Context Awareness)： 代理必须理解用户查询的上下文，才能检索和生成相关信息。
Example: If a user asks for "best restaurants in Paris," the agent should consider the user's preferences, such as cuisine type and budget.
示例： 如果用户询问 "巴黎最好的餐厅"，代理应考虑用户的偏好，例如菜肴类型和预算。

Accuracy:

• The information provided by the agent should be factually correct and up-to-date.
准确性 (Accuracy)： 代理提供的信息应在事实上是正确的且是最新的。
Example: Recommending currently open restaurants with good reviews rather than outdated or closed options.
示例： 推荐当前营业且评价良好的餐厅，而不是过时或已关闭的选项。

User Intent:

• The agent should infer the user's intent behind the query to provide the most relevant information.
用户意图 (User Intent)： 代理应推断用户查询背后的意图，以提供最相关的信息。
Example: If a user asks for "budget-friendly hotels," the agent should prioritize affordable options.
示例： 如果用户询问 "经济实惠的酒店"，代理应优先考虑价格合理的选项。

Feedback Loop:

• Continuously collecting and analyzing user feedback helps the agent refine its relevancy evaluation process.
反馈循环 (Feedback Loop)： 持续收集和分析用户反馈有助于代理改进其相关性评估过程。
Example: Incorporating user ratings and feedback on previous recommendations to improve future responses.
示例： 整合用户对先前推荐的评分和反馈，以改进未来的响应。

Relevance Scoring:

• Assign a relevance score to each retrieved item based on how well it matches the user's query and preferences.

相关性评分 (Relevance Scoring)： 根据每个检索到的项目与用户查询和偏好的匹配程度，为其分配一个相关性评分。

Example:

def relevance_score(item, query):
    score = 0
    if item['category'] in query['interests']:
        score += 1
    if item['price'] <= query['budget']:
        score += 1
    if item['location'] == query['destination']:
        score += 1
    return score

示例： def relevance_score(item, query): score = 0 if item['category'] in query['interests']: score += 1 if item['price'] <= query['budget']: score += 1 if item['location'] == query['destination']: score += 1 return score

Filtering and Ranking:

• Filter out irrelevant items and rank the remaining ones based on their relevance scores.

过滤和排序： 过滤掉不相关的项目，并根据相关性得分对剩余的项目进行排序。

Example:

def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # Return top 10 relevant items

示例： ```python def filter_and_rank(items, query): ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True) return ranked_items[:10] # 返回前10个相关的项目 ```

Natural Language Processing (NLP):

• Use NLP techniques to understand the user's query and retrieve relevant information.

自然语言处理 (NLP)： 使用 NLP (Natural Language Processing) 技术来理解用户的查询并检索相关信息。

Example:

def process_query(query):
    # Use NLP to extract key information from the user's query
    processed_query = nlp(query)
    return processed_query

示例： ```python def process_query(query): # 使用 NLP 从用户的查询中提取关键信息 processed_query = nlp(query) return processed_query ```

User Feedback Integration:

• Collect user feedback on the provided recommendations and use it to adjust future relevance evaluations.

用户反馈整合： 收集用户对所提供建议的反馈，并使用它来调整未来的相关性评估。

Example:

def adjust_based_on_feedback(feedback, items):
    for item in items:
        if item['name'] in feedback['liked']:
            item['relevance'] += 1
        if item['name'] in feedback['disliked']:
            item['relevance'] -= 1
    return items

示例： ```python def adjust_based_on_feedback(feedback, items): for item in items: if item['name'] in feedback['liked']: item['relevance'] += 1 if item['name'] in feedback['disliked']: item['relevance'] -= 1 return items ```

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()
        ranked_hotels = self.filter_and_rank(hotels, self.user_preferences)
        itinerary = create_itinerary(flights, ranked_hotels, attractions)
        return itinerary

    def filter_and_rank(self, items, query):
        ranked_items = sorted(items, key=lambda item: self.relevance_score(item, query), reverse=True)
        return ranked_items[:10]  # Return top 10 relevant items

    def relevance_score(self, item, query):
        score = 0
        if item['category'] in query['interests']:
            score += 1
        if item['price'] <= query['budget']:
            score += 1
        if item['location'] == query['destination']:
            score += 1
        return score

    def adjust_based_on_feedback(self, feedback, items):
        for item in items:
            if item['name'] in feedback['liked']:
                item['relevance'] += 1
            if item['name'] in feedback['disliked']:
                item['relevance'] -= 1
        return items

# 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)"]}
updated_items = travel_agent.adjust_based_on_feedback(feedback, itinerary['hotels'])
print("Updated Itinerary with Feedback:", updated_items)

Understanding User Intent:

• User intent can be categorized into three main types: informational, navigational, and transactional.
  • Informational Intent: The user seeks information about a topic (e.g., "What are the best museums in Paris?").
  理解用户意图： 用户意图可以分为三种主要类型：信息型 (informational)、导航型 (navigational) 和事务型 (transactional)。 信息型意图：用户寻求关于某个主题的信息（例如，“巴黎最好的博物馆有哪些？”）。
Navigational Intent: The user wants to navigate to a specific website or page (e.g., "Louvre Museum official website").
导航型意图：用户想要导航到特定的网站或页面（例如，“卢浮宫官方网站”）。
Transactional Intent: The user aims to perform a transaction, such as booking a flight or making a purchase (e.g., "Book a flight to Paris").
事务型意图：用户旨在执行一项事务，例如预订航班或进行购买（例如，“预订飞往巴黎的航班”）。

Context Awareness:

• Analyzing the context of the user's query helps in accurately identifying their intent. This includes considering previous interactions, user preferences, and the specific details of the current query.
上下文感知： 分析用户查询的上下文有助于准确识别其意图。 这包括考虑之前的交互、用户偏好和当前查询的具体细节。

Natural Language Processing (NLP):

• NLP techniques are employed to understand and interpret the natural language queries provided by users. This includes tasks like entity recognition, sentiment analysis, and query parsing.
自然语言处理 (NLP)： NLP (Natural Language Processing) 技术被用于理解和解释用户提供的自然语言查询。这包括实体识别、情感分析和查询解析等任务。

Personalization:

• Personalizing the search results based on the user's history, preferences, and feedback enhances the relevancy of the information retrieved.
个性化： 根据用户的历史记录、偏好和反馈来个性化搜索结果，可以提高检索信息的相关性。

1. Gathering User Preferences

   class Travel_Agent:
       def __init__(self):
           self.user_preferences = {}
   
       def gather_preferences(self, preferences):
           self.user_preferences = preferences
   

Understanding User Intent

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"

理解用户意图 ```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" ```

Context Awareness

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

上下文感知 ```python def analyze_context(query, user_history): # 将当前查询与用户历史记录相结合以理解上下文 context = { "current_query": query, "user_history": user_history } return context ```

Search and Personalize Results

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

搜索和个性化结果 ```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): # 信息型意图的示例搜索逻辑 results = search_web(f"best {preferences['interests']} in {preferences['destination']}") return results def search_navigation(query): # 导航型意图的示例搜索逻辑 results = search_web(query) return results def search_transaction(query, preferences): # 事务型意图的示例搜索逻辑 results = search_web(f"book {query} to {preferences['destination']}") return results def personalize_results(results, user_history): # 示例个性化逻辑 personalized = [result for result in results if result not in user_history] return personalized[:10] # 返回前 10 个个性化结果 ```

Example Usage

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)

示例用法 ```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. Generating Code as a Tool

Automated Code Generation: Generate code snippets for specific tasks, such as data analysis, web scraping, or machine learning.
自动化代码生成：为特定任务生成代码片段，例如数据分析、网络爬取或机器学习。
SQL as a RAG: Use SQL queries to retrieve and manipulate data from databases.
SQL 作为 RAG (Retrieval-Augmented Generation)：使用 SQL 查询从数据库中检索和操作数据。
Problem Solving: Create and execute code to solve specific problems, such as optimizing algorithms or analyzing data.
问题解决：创建并执行代码以解决特定问题，例如优化算法或分析数据。

Task: Analyze a dataset to identify trends and patterns.
任务：分析数据集以识别趋势和模式。
Steps:
• Load the dataset into a data analysis tool.
步骤： 将数据集加载到数据分析工具中。
Generate SQL queries to filter and aggregate the data.
生成 SQL 查询以过滤和聚合数据。
Execute the queries and retrieve the results.
执行查询并检索结果。
Use the results to generate visualizations and insights.
使用结果生成可视化和见解。
Required Resources: Access to the dataset, data analysis tools, and SQL capabilities.
所需资源：访问数据集、数据分析工具和 SQL 功能。
Experience: Use past analysis results to improve the accuracy and relevance of future analyses.
经验：利用过去的分析结果来提高未来分析的准确性和相关性。

Gathering User Preferences: Collects user input such as destination, travel dates, budget, and interests.
收集用户偏好 (Gathering User Preferences)：收集用户输入，如目的地、旅行日期、预算和兴趣。
Generating Code to Fetch Data: Generates code snippets to retrieve data about flights, hotels, and attractions.
生成代码以获取数据 (Generating Code to Fetch Data)：生成代码片段以检索有关航班、酒店和景点的资料。
Executing Generated Code: Runs the generated code to fetch real-time information.
执行生成的代码 (Executing Generated Code)：运行生成的代码以获取实时信息。
Generating Itinerary: Compiles the fetched data into a personalized travel plan.
生成行程 (Generating Itinerary)：将获取的数据编译成个性化的旅行计划。
Adjusting Based on Feedback: Receives user feedback and regenerates code if necessary to refine the results.
根据反馈进行调整 (Adjusting Based on Feedback)：接收用户反馈，并在必要时重新生成代码以优化结果。

1. Gathering User Preferences

   class Travel_Agent:
       def __init__(self):
           self.user_preferences = {}
   
       def gather_preferences(self, preferences):
           self.user_preferences = preferences
   

Generating Code to Fetch Data

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

生成代码以获取数据 (Generating Code to Fetch Data) ```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 ```

Executing Generated Code

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)

执行生成的代码 (Executing Generated Code) ```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) ```

Generating Itinerary

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)

生成行程 (Generating Itinerary) ```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) ```

Adjusting Based on Feedback

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)

根据反馈进行调整 (Adjusting Based on Feedback) ```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) ```

Understanding the Schema: The system will understand the schema of the table and use this information to ground the query generation.
了解模式 (Understanding the Schema)：系统将了解表的模式，并使用此信息来确定查询生成的基础。
Adjusting Based on Feedback: The system will adjust user preferences based on feedback and reason about which fields in the schema need to be updated.
根据反馈进行调整 (Adjusting Based on Feedback)：系统将根据反馈调整用户偏好，并推理需要更新模式中的哪些字段。
Generating and Executing Queries: The system will generate and execute queries to fetch updated flight and hotel data based on the new preferences.
生成和执行查询 (Generating and Executing Queries)：系统将生成并执行查询，以根据新的偏好获取更新的航班和酒店数据。

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)

Schema Awareness: The schema dictionary defines how preferences should be adjusted based on feedback. It includes fields like favorites and avoid, with corresponding adjustments.
模式感知 (Schema Awareness)：模式字典 (schema dictionary) 定义了应如何根据反馈调整偏好。它包括诸如喜欢 (favorites) 和避免 (avoid) 等字段，以及相应的调整。
Adjusting Preferences (adjust_based_on_feedback method): This method adjusts preferences based on user feedback and the schema.
调整偏好（adjust_based_on_feedback 方法）：此方法根据用户反馈和模式调整偏好。
Environment-Based Adjustments (adjust_based_on_environment method): This method customizes the adjustments based on the schema and feedback.
基于环境的调整（adjust_based_on_environment 方法）：此方法根据模式和反馈自定义调整。
Generating and Executing Queries: The system generates code to fetch updated flight and hotel data based on the adjusted preferences and simulates the execution of these queries.
生成和执行查询 (Generating and Executing Queries)：系统生成代码以根据调整后的偏好获取更新的航班和酒店数据，并模拟这些查询的执行。
Generating Itinerary: The system creates an updated itinerary based on the new flight, hotel, and attraction data.
生成行程 (Generating Itinerary)：系统根据新的航班、酒店和景点数据创建更新的行程。

Database Interaction:

• SQL is used to query databases, retrieve relevant information, and manipulate data.
数据库交互 (Database Interaction)： SQL 用于查询数据库、检索相关信息和操作数据。
Example: Fetching flight details, hotel information, and attractions from a travel database.
示例：从旅游数据库中获取航班详细信息、酒店信息和景点。

Integration with RAG:

• SQL queries are generated based on user input and preferences.
与 RAG 集成 (Integration with RAG)： SQL 查询是根据用户输入和偏好生成的。
The retrieved data is then used to generate personalized recommendations or actions.
然后，检索到的数据用于生成个性化的推荐或操作。

Dynamic Query Generation:

• The AI agent generates dynamic SQL queries based on the context and user needs.
动态查询生成 (Dynamic Query Generation)： 人工智能 (AI) 代理根据上下文和用户需求生成动态 SQL 查询。
Example: Customizing SQL queries to filter results based on budget, dates, and interests.
示例：自定义 SQL 查询以根据预算、日期和兴趣筛选结果。

Automated Code Generation: Generate code snippets for specific tasks.
自动化代码生成 (Automated Code Generation)：为特定任务生成代码片段。
SQL as a RAG: Use SQL queries to manipulate data.
SQL 作为 RAG (Retrieval-Augmented Generation)：使用 SQL 查询来操作数据。
Problem Solving: Create and execute code to solve problems.
问题解决：创建并执行代码来解决问题。

Task: Analyze a dataset to find trends.
任务：分析数据集以发现趋势。
Steps:
• Load the dataset.
步骤： 加载数据集。
Generate SQL queries to filter data.
生成 SQL 查询以过滤数据。
Execute queries and retrieve results.
执行查询并检索结果。
Generate visualizations and insights.
生成可视化和见解。
Resources: Dataset access, SQL capabilities.
资源：数据集访问权限，SQL 功能。
Experience: Use past results to improve future analyses.
经验：使用过去的结果来改进未来的分析。

Gathering User Preferences

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

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

收集用户偏好 ```python class Travel_Agent: def __init__(self): self.user_preferences = {} def gather_preferences(self, preferences): self.user_preferences = preferences ```

Generating SQL Queries

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

生成 SQL 查询 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

Executing SQL Queries

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

执行 SQL 查询 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

Generating Recommendations

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)

生成推荐 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)

Flight Query

SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-10' AND budget='moderate';

航班查询 SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-10' AND budget='moderate';

Hotel Query

SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate';

酒店查询 SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate';

Attraction Query

SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';

景点查询 SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';

Initial Decision: The agent will pick the cheapest hotel, without understanding the quality impact.
初始决策：代理将选择最便宜的酒店，而不了解质量的影响。
Reflection and Evaluation: After the initial choice, the agent will check whether the hotel is a "bad" choice using user feedback. If it finds that the hotel’s quality was too low, it reflects on its reasoning.
反思和评估：在最初选择后，代理将使用用户反馈检查酒店是否是“糟糕”的选择。 如果发现酒店的质量太低，它会反思其推理。
Adjusting Strategy: The agent adjusts its strategy based on its reflection switches from "cheapest" to "highest_quality", thus improving its decision-making process in future iterations.
调整策略：代理根据其反思来调整其策略，从“最便宜”切换到“最高质量”，从而在未来的迭代中改进其决策过程。

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # Stores the hotels chosen previously
        self.corrected_choices = []  # Stores the corrected choices
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # Available strategies

    def recommend_hotel(self, hotels, strategy):
        """
        Recommend a hotel based on the chosen strategy.
        The strategy can either be 'cheapest' or 'highest_quality'.
        """
        if strategy == 'cheapest':
            recommended = min(hotels, key=lambda x: x['price'])
        elif strategy == 'highest_quality':
            recommended = max(hotels, key=lambda x: x['quality'])
        else:
            recommended = None
        self.previous_choices.append((strategy, recommended))
        return recommended

    def reflect_on_choice(self):
        """
        Reflect on the last choice made and decide if the agent should adjust its strategy.
        The agent considers if the previous choice led to a poor outcome.
        """
        if not self.previous_choices:
            return "No choices made yet."

        last_choice_strategy, last_choice = self.previous_choices[-1]
        # Let's assume we have some user feedback that tells us whether the last choice was good or not
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # Adjust strategy if the previous choice was unsatisfactory
            new_strategy = 'highest_quality' if last_choice_strategy == 'cheapest' else 'cheapest'
            self.corrected_choices.append((new_strategy, last_choice))
            return f"Reflecting on choice. Adjusting strategy to {new_strategy}."
        else:
            return "The choice was good. No need to adjust."

    def get_user_feedback(self, hotel):
        """
        Simulate user feedback based on hotel attributes.
        For simplicity, assume if the hotel is too cheap, the feedback is "bad".
        If the hotel has quality less than 7, feedback is "bad".
        """
        if hotel['price'] < 100 or hotel['quality'] < 7:
            return "bad"
        return "good"

# Simulate a list of hotels (price and quality)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# Create an agent
agent = HotelRecommendationAgent()

# Step 1: The agent recommends a hotel using the "cheapest" strategy
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# Step 2: The agent reflects on the choice and adjusts strategy if necessary
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# Step 3: The agent recommends again, this time using the adjusted strategy
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

Evaluate its previous choices and decision-making process.
评估其先前的选择和决策过程。
Adjust its strategy based on that reflection i.e., metacognition in action.
根据该反思调整其策略，即行动中的元认知。

Learning Goals

Core concepts of agent observability and evaluation
代理可观察性和评估的核心概念。
Techniques for improving the performance, costs, and effectiveness of agents
提升代理（agents）的性能、成本和效率的技术
What and how to evaluate your AI agents systematically
如何系统地评估你的 AI 代理 (AI agents)
How to control costs when deploying AI agents to production
如何在将 AI 代理 (AI agents) 部署到生产环境时控制成本
How to instrument agents built with Microsoft Agent Framework
如何对使用 Microsoft Agent Framework 构建的代理进行检测 (instrument)

Trace represents a complete agent task from start to finish (like handling a user query).
追踪 (Trace) 表示从开始到结束的完整代理任务（例如处理用户查询）。
Spans are individual steps within the trace (like calling a language model or retrieving data).
跨度 (Spans) 是追踪 (trace) 中的各个步骤（例如调用语言模型或检索数据）。

Debugging and Root-Cause Analysis: When an agent fails or produces an unexpected output, observability tools provide the traces needed to pinpoint the source of the error. This is especially important in complex agents that might involve multiple LLM calls, tool interactions, and conditional logic.
调试和根本原因分析：当代理失败或产生意外输出时，可观测性工具 (observability tools) 提供所需的追踪 (traces) 来查明错误的来源。这在可能涉及多个 LLM 调用、工具交互和条件逻辑的复杂代理中尤为重要。
Latency and Cost Management: AI agents often rely on LLMs and other external APIs that are billed per token or per call. Observability allows for precise tracking of these calls, helping to identify operations that are excessively slow or expensive. This enables teams to optimize prompts, select more efficient models, or redesign workflows to manage operational costs and ensure a good user experience.
延迟和成本管理：AI 代理 (AI agents) 通常依赖于按令牌或每次调用计费的 LLM 和其他外部 API。可观测性 (Observability) 可以精确跟踪这些调用，从而帮助识别速度过慢或成本过高的操作。这使团队能够优化提示词 (prompts)、选择更有效的模型或重新设计工作流程，以管理运营成本并确保良好的用户体验。
Trust, Safety, and Compliance: In many applications, it's important to ensure that agents behave safely and ethically. Observability provides an audit trail of agent actions and decisions. This can be used to detect and mitigate issues like prompt injection, the generation of harmful content, or the mishandling of personally identifiable information (PII). For example, you can review traces to understand why an agent provided a certain response or used a specific tool.
信任、安全和合规性：在许多应用中，确保代理的行为安全且符合伦理非常重要。可观测性 (Observability) 提供了代理操作和决策的审计跟踪。这可用于检测和缓解诸如提示词注入 (prompt injection)、有害内容的生成或个人身份信息 (PII) 处理不当之类的问题。例如，你可以查看追踪 (traces) 以了解代理为何提供特定响应或使用了特定工具。
Continuous Improvement Loops: Observability data is the foundation of an iterative development process. By monitoring how agents perform in the real world, teams can identify areas for improvement, gather data for fine-tuning models, and validate the impact of changes. This creates a feedback loop where production insights from online evaluation inform offline experimentation and refinement, leading to progressively better agent performance.
持续改进循环：可观测性数据 (Observability data) 是迭代开发过程的基础。通过监视代理在现实世界中的表现，团队可以确定需要改进的领域，收集数据以微调模型，并验证更改的影响。这创建了一个反馈循环，在线评估的生产见解告知离线实验和改进，从而逐步提高代理性能。

from agent_framework.observability import get_tracer, get_meter

tracer = get_tracer()
meter = get_meter()

with tracer.start_as_current_span("agent_run"):
    # Agent execution is traced automatically
    pass

from langfuse import get_client
 
langfuse = get_client()
 
span = langfuse.start_span(name="my-span")
 
span.end()

Introduction

Learning Goals

Connection: The AI assistant (the MCP client) connects to an MCP server provided by an airline.

连接 (Connection)：AI 助手（MCP 客户端 (MCP client)）连接到航空公司提供的 MCP 服务器。

Tool Discovery: The client asks the airline's MCP server, "What tools do you have available?" The server responds with tools like "search flights" and "book flights".

工具发现 (Tool Discovery)：客户端询问航空公司的 MCP 服务器：“你们有哪些可用的工具？”服务器响应诸如“搜索航班 (search flights)”和“预订航班 (book flights)”之类的工具。

Tool Invocation: You then ask the AI assistant, "Please search for a flight from Portland to Honolulu." The AI assistant, using its LLM, identifies that it needs to call the "search flights" tool and passes the relevant parameters (origin, destination) to the MCP server.

工具调用 (Tool Invocation)：然后，您询问 AI 助手：“请搜索从波特兰到檀香山的航班。”AI 助手使用其 LLM，识别出它需要调用“搜索航班”工具，并将相关参数（始发地、目的地）传递给 MCP 服务器。

Execution and Response: The MCP server, acting as a wrapper, makes the actual call to the airline's internal booking API. It then receives the flight information (e.g., JSON data) and sends it back to the AI assistant.

执行和响应 (Execution and Response)：MCP 服务器充当包装器 (wrapper)，实际调用航空公司的内部预订 API。然后，它接收航班信息（例如，JSON 数据）并将其发送回 AI 助手。

Further Interaction: The AI assistant presents the flight options. Once you select a flight, the assistant might invoke the "book flight" tool on the same MCP server, completing the booking.

进一步交互 (Further Interaction)：AI 助手会显示航班选项。选择航班后，助手可能会在同一 MCP 服务器上调用“预订航班”工具，从而完成预订。

The Name of the Agent .
代理的名称 (Name of the Agent)。
A description of the general tasks it completes.
对其完成的常规任务的描述。
A list of specific skills with descriptions to help other agents (or even human users) understand when and why they would want to call that agent.
包含具体技能列表及其描述，以帮助其他代理（甚至人类用户）理解何时以及为何他们想要调用该代理。
The current Endpoint URL of the agent
代理的当前端点 URL (Endpoint URL)。
The version and capabilities of the agent such as streaming responses and push notifications.
代理的版本和能力，例如流式响应和推送通知。

User Request to Multi-Agent: A user interacts with a "Travel Agent" A2A client/agent, perhaps by saying, "Please book an entire trip to Honolulu for next week, including flights, a hotel, and a rental car".

用户向多智能体发出的请求：用户与“旅行社代理”(Travel Agent) A2A 客户端/代理进行交互，例如说：“请预订下周前往檀香山（Honolulu）的整个行程，包括航班、酒店和租车”。

Orchestration by Travel Agent: The Travel Agent receives this complex request. It uses its LLM to reason about the task and determine that it needs to interact with other specialized agents.

旅行社代理的编排：旅行社代理收到这个复杂的请求。它利用其 LLM 来推理任务，并确定需要与其他专业代理进行交互。

Inter-Agent Communication: The Travel Agent then uses the A2A protocol to connect to downstream agents, such as an "Airline Agent," a "Hotel Agent," and a "Car Rental Agent" that are created by different companies.

智能体间通信：然后，旅行社代理使用 A2A 协议连接到下游代理，例如由不同公司创建的“航空公司代理”(Airline Agent)、“酒店代理”(Hotel Agent) 和“汽车租赁代理”(Car Rental Agent)。

Delegated Task Execution: The Travel Agent sends specific tasks to these specialized agents (e.g., "Find flights to Honolulu," "Book a hotel," "Rent a car"). Each of these specialized agents, running their own LLMs and utilizing their own tools (which could be MCP servers themselves), performs its specific part of the booking.

委托任务执行：旅行社代理将特定任务发送给这些专门的代理（例如，“查找前往檀香山的航班”、“预订酒店”、“租一辆车”）。这些专业代理各自运行自己的 LLM，并利用自己的工具（这些工具本身可以是 MCP 服务器 (MCP server)），执行其预订的特定部分。

Consolidated Response: Once all downstream agents complete their tasks, the Travel Agent compiles the results (flight details, hotel confirmation, car rental booking) and sends a comprehensive, chat-style response back to the user.

整合响应：一旦所有下游代理完成其任务，旅行社代理就会汇编结果（航班详细信息、酒店确认信息、汽车租赁预订信息），并将全面的聊天式响应发送回用户。

NLWeb Application (Core Service Code): The system that processes natural language questions. It connects the different parts of the platform to create responses. You can think of it as the engine that powers the natural language features of a website.

NLWeb 应用程序（核心服务代码）：处理自然语言问题的系统。 它连接平台的各个部分以创建响应。 您可以将其视为为网站的自然语言功能提供支持的引擎。

NLWeb Protocol: This is a basic set of rules for natural language interaction with a website. It sends back responses in JSON format (often using Schema.org). Its purpose is to create a simple foundation for the “AI Web,” in the same way that HTML made it possible to share documents online.

NLWeb 协议：这是一组与网站进行自然语言交互的基本规则。 它以 JSON 格式（通常使用 Schema.org）发回响应。 它的目的是为“AI Web”创建一个简单的基础，就像 HTML 使在线共享文档成为可能一样。

MCP Server (Model Context Protocol Endpoint): Each NLWeb setup also works as an MCP server. This means it can share tools (like an “ask” method) and data with other AI systems. In practice, this makes the website’s content and abilities usable by AI agents, allowing the site to become part of the wider “agent ecosystem.”

MCP 服务器（模型上下文协议端点）(Model Context Protocol Endpoint)：每个 NLWeb 设置也可以作为 MCP 服务器工作。 这意味着它可以与其他 AI 系统共享工具（如“ask”方法）和数据。 实际上，这使得网站的内容和能力可供 AI 代理使用，从而使该网站成为更广泛的“代理生态系统”的一部分。

Embedding Models: These models are used to convert website content into numerical representations called vectors (embeddings). These vectors capture meaning in a way computers can compare and search. They are stored in a special database, and users can choose which embedding model they want to use.

嵌入模型：这些模型用于将网站内容转换为称为向量（嵌入）(embeddings) 的数字表示形式。 这些向量以计算机可以比较和搜索的方式捕获含义。 它们存储在特殊的数据库中，用户可以选择他们想要使用的嵌入模型。

Vector Database (Retrieval Mechanism): This database stores the embeddings of the website content. When someone asks a question, NLWeb checks the vector database to quickly find the most relevant information. It gives a fast list of possible answers, ranked by similarity. NLWeb works with different vector storage systems such as Qdrant, Snowflake, Milvus, Azure AI Search, and Elasticsearch.

向量数据库（检索机制）：此数据库存储网站内容的嵌入。 当有人提出问题时，NLWeb 会检查向量数据库以快速找到最相关的信息。 它提供了一个按相似性排序的可能答案的快速列表。 NLWeb 适用于不同的向量存储系统，例如 Qdrant、Snowflake、Milvus、Azure AI Search 和 Elasticsearch。

Data Ingestion: The travel website's existing product catalogs (e.g., flight listings, hotel descriptions, tour packages) are formatted using Schema.org or loaded via RSS feeds. NLWeb's tools ingest this structured data, create embeddings, and store them in a local or remote vector database.

数据摄取：旅行网站现有的产品目录（例如，航班列表、酒店描述、旅游套餐）使用 Schema.org 格式化或通过 RSS 订阅源加载。 NLWeb 的工具摄取此结构化数据，创建嵌入，并将它们存储在本地或远程向量数据库中。

Natural Language Query (Human): A user visits the website and, instead of navigating menus, types into a chat interface: "Find me a family-friendly hotel in Honolulu with a pool for next week".

自然语言查询（人类）：用户访问该网站，没有浏览菜单，而是在聊天界面中输入：“在檀香山为我寻找一家带有游泳池的适合家庭的酒店，下周入住”。

NLWeb Processing: The NLWeb application receives this query. It sends the query to an LLM for understanding and simultaneously searches its vector database for relevant hotel listings.

NLWeb 处理：NLWeb 应用程序接收此查询。 它将查询发送到 LLM 以进行理解，同时在其向量数据库中搜索相关的酒店列表。

Accurate Results: The LLM helps to interpret the search results from the database, identify the best matches based on "family-friendly," "pool," and "Honolulu" criteria, and then formats a natural language response. Crucially, the response refers to actual hotels from the website's catalog, avoiding made-up information.

准确的结果：LLM 帮助解释数据库的搜索结果，根据“适合家庭”、“游泳池”和“檀香山”标准识别最佳匹配项，然后格式化自然语言响应。 至关重要的是，响应指的是网站目录中的实际酒店，避免了虚构信息。

AI Agent Interaction: Because NLWeb serves as an MCP server, an external AI travel agent could also connect to this website's NLWeb instance. The AI agent could then use the ask MCP method to query the website directly: ask("Are there any vegan-friendly restaurants in the Honolulu area recommended by the hotel?"). The NLWeb instance would process this, leveraging its database of restaurant information (if loaded), and return a structured JSON response.

AI 代理交互：由于 NLWeb 充当 MCP 服务器，因此外部 AI 旅行社代理也可以连接到此网站的 NLWeb 实例。 然后，AI 代理可以使用 ask MCP 方法直接查询网站：ask("酒店推荐在檀香山地区是否有任何适合素食主义者的餐厅？")。 NLWeb 实例将处理此请求，利用其餐厅信息数据库（如果已加载），并返回结构化的 JSON 响应。

Introduction

This lesson will cover:

Learning Goals

Define Clear Results - The results of the tasks that AI Agents will be assigned should be clearly defined. Answer the question - "What will the world look like when the AI Agent is done with its task?" In other words, what change, information, or response should the user have after interacting with the AI Agent.
定义明确的结果 (Define Clear Results) - 应该明确定义分配给 AI 代理 (AI Agents) 的任务的结果。回答问题——“当 AI 代理完成其任务时，世界会是什么样子？” 换句话说，用户在与 AI 代理交互后应该获得什么样的改变、信息或回应。
Map the Context - Once you have defined the results of the AI Agent, you need to answer the question of "What information does the AI Agent need in order to complete this task?". This way you can start to map the context of where that information can be located.
映射上下文 (Map the Context) - 一旦您定义了 AI 代理 (AI Agent) 的结果，您需要回答“AI 代理需要什么信息才能完成此任务？”的问题。这样您就可以开始映射可以找到该信息的上下文 (context)。
Create Context Pipelines - Now that you know where the information is, you need to answer the question "How will the Agent get this information?". This can be done in a variety of ways including RAG, use of MCP servers and other tools.
创建上下文管道 (Create Context Pipelines) - 既然您知道信息在哪里，您需要回答“代理将如何获取此信息？”的问题。这可以通过多种方式完成，包括 RAG、使用 MCP 服务器和其他工具。

Agent Scratchpad This allows for an AI Agent to takes notes of relevant information about the current tasks and user interactions during a single session. This should exist outside of the context window in a file or runtime object that the agent can later retrieve during this session if needed.

代理草稿纸 (Agent Scratchpad) 这允许 AI 代理 (AI Agent) 记录关于当前任务和用户交互的相关信息，在单个会话期间。这应该存在于上下文窗口 (context window) 之外的文件或运行时对象中，代理可以在需要时在本次会话期间稍后检索。

Memories Scratchpads are good for managing information outside of the context window of a single session. Memories enable agents to store and retrieve relevant information across multiple sessions. This could include summaries, user preferences and feedback for improvements in the future.

记忆 (Memories) 草稿纸 (Scratchpads) 擅长于管理单个会话的上下文窗口 (context window) 之外的信息。记忆 (Memories) 使代理能够跨多个会话存储和检索相关信息。这可能包括摘要、用户偏好以及对未来改进的反馈。

Compressing Context Once the context window grows and is nearing its limit, techniques such as summarization and trimming can be used. This includes either keeping only the most relevant information or removing older messages.

压缩上下文 (Compressing Context) 一旦上下文窗口 (context window) 增长并接近其限制，就可以使用诸如摘要 (summarization) 和修剪 (trimming) 之类的技术。这包括仅保留最相关的信息或删除较旧的消息。

Multi-Agent Systems Developing multi-agent system is a form of context engineering because each agent has its own context window. How that context is shared and passed to different agents is another thing to plan out when building these systems.

多代理系统 (Multi-Agent Systems) 开发多代理系统 (multi-agent system) 是一种上下文工程 (context engineering) 的形式，因为每个代理都有其自己的上下文窗口 (context window)。如何在不同代理之间共享和传递上下文 (context) 是构建这些系统时需要计划的另一件事。

Sandbox Environments If an agent needs to run some code or process large amounts of information in a document, this can take a large amount of tokens to process the results. Instead of having this all stored in the context window, the agent can use a sandbox environment that is able to run this code and only read the results and other relevant information.

沙盒环境 (Sandbox Environments) 如果代理需要运行一些代码或处理文档中的大量信息，则可能需要大量的 tokens 才能处理结果。代理可以使用沙盒环境 (sandbox environment) 来运行此代码，而无需将所有内容都存储在上下文窗口 (context window) 中，并且仅读取结果和其他相关信息。

Runtime State Objects This is done by creating containers of information to manage situations when the Agent needs to have access to certain information. For a complex task, this would enable an Agent to store the results of each subtask step by step, allowing the context to remain connected only to that specific subtask.

运行时状态对象 (Runtime State Objects) 这是通过创建信息容器来管理代理需要访问某些信息的情况来完成的。对于复杂的任务，这将使代理能够逐步存储每个子任务的结果，从而使上下文 (context) 仅与该特定子任务保持连接。

Then, an example response could be: "Hey [Your Name]! I see you're free the first week of October. Shall I look for direct flights to Paris on [Preferred Airline] within your usual budget of [Budget]?". This richer, context-aware response demonstrates the power of context engineering.
然后，一个示例回复可能是：“嘿 [您的名字]！我看到您在十月的第一周有空。我应该在您通常的 [预算] 预算内寻找 [首选航空公司] 飞往巴黎的直飞航班吗？” 这种更丰富、上下文感知的响应展示了上下文工程 (context engineering) 的力量。

agent = AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent( instructions="You are good at recommending trips to customers based on their preferences.", name="TripRecommender" )

AzureAIAgentClient(async_credential=credential).create_agent( name="HelperAgent", instructions="You are a helpful assistant." ) as agent

agent = OpenAIResponsesClient().create_agent( name="WeatherBot", instructions="You are a helpful weather assistant.", )

agent = OpenAIChatClient().create_agent( name="HelpfulAssistant", instructions="You are a helpful assistant.", )

agent = A2AAgent( name=agent_card.name, description=agent_card.description, agent_card=agent_card, url="https://your-a2a-agent-host" )

result = await agent.run("What are good places to visit in Amsterdam?")
print(result.text)

async for update in agent.run_stream("What are the good places to visit in Amsterdam?"):
    if update.text:
        print(update.text, end="", flush=True)

def get_attractions( location: Annotated[str, Field(description="The location to get the top tourist attractions for")], ) -> str: """Get the top tourist attractions for a given location.""" return f"The top attractions for {location} are." 


# When creating a ChatAgent directly 

agent = ChatAgent( chat_client=OpenAIChatClient(), instructions="You are a helpful assistant", tools=[get_attractions]

result1 = await agent.run( "What's the best place to visit in Seattle?", tools=[get_attractions] # Tool provided for this run only )

# Create a new thread. 
thread = agent.get_new_thread() # Run the agent with the thread. 
response = await agent.run("Hello, I am here to help you book travel. Where would you like to go?", thread=thread)

# Create a new thread. 
thread = agent.get_new_thread() 

# Run the agent with the thread. 

response = await agent.run("Hello, how are you?", thread=thread) 

# Serialize the thread for storage. 

serialized_thread = await thread.serialize() 

# Deserialize the thread state after loading from storage. 

resumed_thread = await agent.deserialize_thread(serialized_thread)

async def logging_function_middleware(
    context: FunctionInvocationContext,
    next: Callable[[FunctionInvocationContext], Awaitable[None]],
) -> None:
    """Function middleware that logs function execution."""
    # Pre-processing: Log before function execution
    print(f"[Function] Calling {context.function.name}")

    # Continue to next middleware or function execution
    await next(context)

    # Post-processing: Log after function execution
    print(f"[Function] {context.function.name} completed")

async def logging_chat_middleware(
    context: ChatContext,
    next: Callable[[ChatContext], Awaitable[None]],
) -> None:
    """Chat middleware that logs AI interactions."""
    # Pre-processing: Log before AI call
    print(f"[Chat] Sending {len(context.messages)} messages to AI")

    # Continue to next middleware or AI service
    await next(context)

    # Post-processing: Log after AI response
    print("[Chat] AI response received")

# Create a new thread. 
thread = agent.get_new_thread() # Run the agent with the thread. 
response = await agent.run("Hello, I am here to help you book travel. Where would you like to go?", thread=thread)

from agent_framework import ChatMessageStore

# Create a custom message store
def create_message_store():
    return ChatMessageStore()

agent = ChatAgent(
    chat_client=OpenAIChatClient(),
    instructions="You are a Travel assistant.",
    chat_message_store_factory=create_message_store
)

from agent_framework.mem0 import Mem0Provider

# Using Mem0 for advanced memory capabilities
memory_provider = Mem0Provider(
    api_key="your-mem0-api-key",
    user_id="user_123",
    application_id="my_app"
)

agent = ChatAgent(
    chat_client=OpenAIChatClient(),
    instructions="You are a helpful assistant with memory.",
    context_providers=memory_provider
)

from agent_framework.observability import get_tracer, get_meter

tracer = get_tracer()
meter = get_meter()
with tracer.start_as_current_span("my_custom_span"):
    # do something
    pass
counter = meter.create_counter("my_custom_counter")
counter.add(1, {"key": "value"})

from agent_framework import WorkflowBuilder

builder = WorkflowBuilder()
builder.add_edge(source_executor, target_executor)
builder.set_start_executor(source_executor)
workflow = builder.build()