# AI代理推理过程中的示例用法
代理查询 = "用简单的术语解释AI代理的概念。"
llm输出 = get_llm_response(代理查询)
打印(f"LLM响应: {llm输出}")
```

```zh
index_name = "ai-agent-memory"
如果 index_name 不在 pc.list_indexes() 中：
    pc.create_index(
        name=index_name,
        dimension=1536,  # OpenAI ada-002 嵌入的维度
        metric='cosine',
        spec=ServerlessSpec(cloud='aws', region='us-east-1')
    )
index = pc.Index(index_name)
print(f"已初始化 Pinecone 索引 {index_name}.")

3.  **生成嵌入并插入数据：** 此函数接收文本数据，使用 OpenAI 生成嵌入，并将其存储在 Pinecone 中。
```python
def get_embedding(text, model="text-embedding-ada-002"):
    text = text.replace("\n", " ")
    return openai_client.embeddings.create(input=[text], model=model).data[0].embedding

def upsert_memory(id, text, metadata=None):
    embedding = get_embedding(text)
    index.upsert(vectors=[{"id": id, "values": embedding, "metadata": metadata}])
    print(f"内存 ID {id} 已插入.")

# 示例：存储过去的对话轮次或文档片段
upsert_memory("conv_123", "用户询问了 AI 代理在医疗保健中的好处。", {"type": "conversation", "timestamp": "2025-09-04T10:00:00Z"})
upsert_memory("doc_456", "AI 代理可以自动安排患者的预约并提高诊断准确性。", {"type": "document", "source": "healthcare_report.pdf"})

def retrieve_memory(query_text, top_k=3):
    query_embedding = get_embedding(query_text)
    results = index.query(vector=query_embedding, top_k=top_k, include_metadata=True)
    retrieved_texts = []
    for match in results.matches:
        retrieved_texts.append(match.metadata["text"] if "text" in match.metadata else f"分数: {match.score}, ID: {match.id}")
        # 对于上面的示例，我们需要在元数据中存储原始文本。
        # 让我们改进 upsert_memory 以包含文本元数据，以便更容易检索。
        # upsert_memory("conv_123", "用户询问了 AI 代理在医疗保健中的好处。", {"type": "conversation", "timestamp": "2025-09-04T10:00:00Z", "text": "用户询问了 AI 代理在医疗保健中的好处。"})
    return retrieved_texts

# 示例：代理需要根据过去的互动或文档回答问题
agent_question = "AI 代理在医疗保健中的应用有哪些？"
relevant_info = retrieve_memory(agent_question)
print(f"检索到的相关信息: {relevant_info}")

pip install chromadb langchain-openai

import chromadb
from langchain_openai import OpenAIEmbeddings
from langchain_core.documents import Document

# 初始化 OpenAI 嵌入
embeddings_model = OpenAIEmbeddings(openai_api_key=os.environ.get("OPENAI_API_KEY"))

# 初始化 ChromaDB 客户端（为了简化使用内存，可以持久化）
client = chromadb.Client()
collection_name = "ai_agent_local_memory"
try:
    collection = client.get_or_create_collection(name=collection_name)
except Exception as e:
    print(f"获取/创建集合时出错: {e}")
    # 如果集合已经存在且错误是由于此原因导致的，尝试再次获取
    collection = client.get_collection(name=collection_name)

def add_documents_to_chroma(texts, metadatas=None):
    docs = [Document(page_content=text, metadata=meta if meta else {}) for text, meta in zip(texts, metadatas or [{} for _ in texts])]
    # 生成嵌入并添加到集合中
    # 如果配置正确，ChromaDB 可以内部处理嵌入生成，或者您可以传递预计算的嵌入。
    # 为了简单起见，假设我们传递文本，ChromaDB 将处理使用配置的模型的嵌入。
    # 然而，Langchain 的 Chroma 集成通常期望嵌入由嵌入函数处理。
    # 让我们使用直接的方法来添加带有预计算嵌入的文档以提高清晰度。
    ids = [f"doc_{i}" for i in range(len(texts))]
    embeddings = [embeddings_model.embed_query(text) for text in texts]
    collection.add(embeddings=embeddings, documents=texts, metadatas=metadatas, ids=ids)
    print(f"已向 ChromaDB 添加 {len(texts)} 个文档.")

documents_to_add = [
    "最新研究表明，人工智能代理可以显著降低运营成本。",
    "客户服务人工智能代理正在将解决时间提高30%。",
    "自主人工智能代理的伦理影响需要仔细考虑。"
]
metadatas_to_add = [
    {"source": "研究论文"},
    {"source": "案例研究"},
    {"source": "伦理指南"}
]
add_documents_to_chroma(documents_to_add, metadatas_to_add)
```

获取给定位置的当前天气。
        位置应该是城市名称，例如“伦敦”。 
        """
        try:
            # 在实际应用中，您将使用天气API密钥和更强大的服务。
            # 这是一个简化的示例。
            api_key = "您的天气API密钥"  # 替换为真实的API密钥
            base_url = f"http://api.openweathermap.org/data/2.5/weather?q={location}&appid={api_key}&units=metric"
            response = requests.get(base_url)
            response.raise_for_status()  # 对HTTP错误引发异常
            weather_data = response.json()
            if weather_data["cod"] == 200:
                main = weather_data["main"]
                weather_desc = weather_data["weather"][0]["description"]
                temp = main["temp"]
                humidity = main["humidity"]
                return f"{location}的当前天气是{weather_desc}，气温为{temp}°C，湿度为{humidity}%。"
            else:
                return f"无法获取{location}的天气。错误：{weather_data.get('message', '未知错误')}"
        except requests.exceptions.RequestException as e:
            return f"获取天气时发生错误：{e}"
        except Exception as e:
            return f"发生了意外错误：{e}"
    ```

2.  **将工具集成到代理中：** 定义完成后，工具可以传递给您的LangChain代理。
    ```python
    from langchain_openai import ChatOpenAI
    from langchain.agents import AgentExecutor, create_react_agent
    from langchain import hub

    # 初始化LLM
    llm = ChatOpenAI(model="gpt-4o", temperature=0)

    # 代理可用工具列表
    tools = [
        get_current_weather,  # 我们的自定义天气工具
        # 如果需要，您可以在这里添加其他工具，例如先前示例中的calculator_tool
    ]

    # 获取要使用的提示
    prompt = hub.pull("hwchase17/react")

    # 创建代理
    agent = create_react_agent(llm, tools, prompt)

    # 创建代理执行器
    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

    # 示例用法：代理请求天气信息
    response = agent_executor.invoke({"input": "东京的天气怎么样？"})
    print(f"代理响应：{response['output']}")
    ```

**解决方案：利用OpenAI函数进行工具调用**

OpenAI的函数调用功能允许开发者为GPT模型描述函数，然后模型可以智能地选择输出包含调用这些函数参数的JSON对象。此功能简化了启用代理与外部工具和API交互的过程，因为LLM本身处理何时以及如何根据用户提示使用工具的决策。这是许多现代AI代理技术栈实现的核心组成部分。

**代码操作步骤（Python与OpenAI函数调用示例）：**

1.  **定义一个供代理调用的函数：**
    ```python
    import json
    from openai import OpenAI
    import os

    client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

    # 获取当前天气的示例函数
    def get_current_weather_openai(location, unit="celsius"):
        """获取给定位置的当前天气"""
        if "东京" in location.lower():
            return json.dumps({"location": location, "temperature": "25", "unit": unit})
        elif "旧金山" in location.lower():
            return json.dumps({"location": location, "temperature": "22", "unit": unit})
        elif "巴黎" in location.lower():
            return json.dumps({"location": location, "temperature": "28", "unit": unit})
        else:
            return json.dumps({"location": location, "temperature": "未知"})

    # 定义模型可用的工具
    tools_openai = [
        {
            "type": "function",
            "function": {
                "name": "get_current_weather_openai",
                "description": "获取给定位置的当前天气",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "城市和州，例如旧金山, CA",
                        },
                        "unit": {
                            "type": "string",
                            "enum": ["celsius", "fahrenheit"]},
                    },
                    "required": ["location"],
                },
            },
        }
    ]
    ```

2.  **使用工具定义发起聊天完成请求：**
    ```python
    def run_conversation(user_message):
        messages = [{"role": "user", "content": user_message}]
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=tools_openai,
    ```
工具选择="自动"，  # 自动是默认，但我们将明确指定
        )
        响应消息 = response.choices[0].message
        工具调用 = 响应消息.tool_calls

        # 第 2 步：检查模型是否想要调用工具
        如果 工具调用:
            # 第 3 步：调用工具
            # 注意：JSON 响应可能并不总是有效；请确保处理错误
            可用功能 = {
                "get_current_weather_openai": get_current_weather_openai,
            }
            消息.append(响应消息)  # 扩展与助手的对话回复
            对于 工具调用 中的 工具调用:
                功能名称 = 工具调用.function.name
                要调用的功能 = 可用功能[功能名称]
                功能参数 = json.loads(工具调用.function.arguments)
                功能响应 = 要调用的功能(
                    location=功能参数.get("location"),
                    unit=功能参数.get("unit"),
                )
                消息.append(
                    {
                        "tool_call_id": 工具调用.id,
                        "角色": "tool",
                        "名称": 功能名称,
                        "内容": 功能响应,
                    }
                )  # 扩展与工具输出的对话
            第二响应 = client.chat.completions.create(
                model="gpt-4o",
                messages=消息,
            )
            return 第二响应.choices[0].message.content
        否则:
            return 响应消息.content

    # 示例用法
    print(run_conversation("旧金山的天气怎么样？"))
    print(run_conversation("给我讲个笑话。")) # 示例，没有调用工具
    ```

工具集成是功能性人工智能代理的基石，使其能够超越简单对话，执行具体操作并访问现实世界的信息。这种能力使人工智能代理在数据分析到自动化客户服务等各种应用中真正自主并具有价值。工具库和集成方法的持续发展是人工智能代理技术栈中的关键创新领域。




### 5. 数据收集与集成

数据是任何人工智能系统的核心，人工智能代理也不例外。在人工智能代理能够有效推理、计划或行动之前，它需要理解其所处的世界。这种理解源自现实世界、实时且通常是非结构化的数据。无论是训练模型、支持检索增强生成（RAG）系统，还是使代理能够响应实时市场变化，数据都是推动智能行为的燃料。因此，强大的 [数据收集](https://www.scrapeless.com/zh/solutions/data-collection) 和集成机制是人工智能代理技术栈的重要组成部分。

有效的数据收集涉及从多样化的来源获取相关信息，这些来源可以包括公共网页数据、内部数据库、API 和用户输入。数据集成则确保这些不同的信息被转换为可用格式并对人工智能代理可访问。在这方面的挑战通常包括处理反机器人保护、处理各种数据格式以及确保数据质量和新鲜度。该领域的解决方案旨在自动化和简化数据获取和准备以供代理使用的过程。

**解决方案：利用网络爬虫 API 实现实时数据获取**

对于需要从公共网络获取最新信息的人工智能代理，网络爬虫 API 提供了一种强大的解决方案。这些服务可以绕过常见的网络限制，从网站提取结构化数据，并以干净、可用的格式提供。对于执行市场分析、竞争情报或内容聚合的代理，这尤其有价值。例如，一个 [电子商务](https://www.scrapeless.com/zh/solutions/e-commerce) 情报代理可能会利用网络爬虫 API 实时监控竞争对手的定价和产品可用性。

**代码操作步骤（使用假设的网络爬虫 API 示例的 Python 示例）：**

1.  **安装 requests 库（如果尚未安装）：**
    ```bash
    pip install requests
    ```

2.  **使用网络爬虫 API 获取数据：** 此示例使用通用网络爬虫 API 的占位符。在实际场景中，您将使用 Bright Data、Oxylabs 或 Scrapeless 等服务。
    ```python
    import requests
    import json

    def fetch_product_data(product_url, api_key="YOUR_SCRAPING_API_KEY"):
        """使用网络爬虫 API 从给定 URL 获取产品数据。"""
        api_endpoint = "https://api.example.com/scrape" # 占位符 API 端点
        headers = {"Content-Type": "application/json"}
        payload = {
            "api_key": api_key,
            "url": product_url,
“解析”: 真，# 请求结构化解析 
            “选择器”: “#product-details” # 产品详情的示例 CSS 选择器 
        } 
        试: 
            响应 = requests.post(api_endpoint, headers=headers, data=json.dumps(payload)) 
            响应.raise_for_status() # 对于错误响应引发 HTTPError 
            返回响应.json() 
        除了 requests.exceptions.RequestException 作为 e: 
            返回 f"获取数据时出错: {e}" 

    # AI 代理的示例用法 
    competitor_product_url = "https://www.example-competitor.com/product/xyz" 
    product_info = fetch_product_data(competitor_product_url) 
    如果 isinstance(product_info, dict) 和 "data" 在 product_info 中: 
        打印(f"获取的产品名称: {product_info['data'].get('name')}") 
        打印(f"获取的产品价格: {product_info['data'].get('price')}") 
    否则: 
        打印(product_info) 
    ```

**解决方案：与内部数据库和数据仓库集成**

许多 AI 代理需要访问和处理内部公司数据库、数据仓库或数据湖中的数据。这需要强大的连接器和数据集成管道，以确保代理能够访问最新和相关的操作数据。解决方案通常涉及使用标准数据库连接器、ETL（提取、转换、加载）工具或实时数据流平台。

**代码操作步骤（使用 SQLAlchemy 进行数据库集成的 Python）：**

1.  **安装 SQLAlchemy 和数据库驱动程序（例如，psycopg2 用于 PostgreSQL）：**
    ```bash
    pip install sqlalchemy psycopg2-binary
    ```

2.  **连接到数据库并获取数据：**
    ```python
    from sqlalchemy import create_engine, text

    def get_customer_data(customer_id):
        """从内部数据库获取客户数据。"""
        # 用您的实际数据库连接字符串替换
        db_connection_str = "postgresql+psycopg2://user:password@host:port/dbname"
        engine = create_engine(db_connection_str)

        尝试:
            with engine.connect() as connection:
                query = text("SELECT * FROM customers WHERE customer_id = :id")
                result = connection.execute(query, {"id": customer_id}).fetchone()
                如果结果:
                    返回 dict(result._mapping) # 将 RowMapping 转换为字典
                else:
                    返回 None
        除了 Exception 作为 e:
            返回 f"数据库错误: {e}"

    # AI 代理的示例用法（例如，客户支持代理）
    customer_info = get_customer_data(101)
    如果 customer_info:
        打印(f"客户姓名: {customer_info.get('name')}，电子邮件: {customer_info.get('email')}")
    else:
        打印("客户未找到或发生错误。")
    ```

数据收集和集成是任何 AI 代理能力的基础。如果没有准确、及时和可访问的数据，即使是最复杂的 LLM 和框架也将受到严重限制。该领域工具和服务的不断演变确保 AI 代理可以获得执行其任务所需的丰富信息。这是 Scrapeless 等服务可以提供显著价值的地方，为您的 AI 代理技术栈提供可靠且可扩展的数据获取解决方案。

### 6. 代理托管和部署

一旦 AI 代理开发和测试完成，就需要一个强大的环境来持续和大规模地运行。代理托管和部署指的是将 AI 代理在生产环境中可访问和可操作所需的基础设施和流程。与传统应用程序不同，AI 代理通常具有独特的要求，例如持久状态管理、安全工具执行和动态资源分配。AI 代理技术栈的这一层确保代理能够可靠运行，与用户和其他系统进行交互，并根据需求进行扩展。

AI 代理的部署策略可以有很大差异，从将它们作为长期运行的服务运行到将其作为无服务器功能调用。关键考量包括可扩展性、成本效益、安全性和易管理性。随着 AI 代理变得越来越复杂和自主，对能够处理它们的状态性质和工具调用能力的专用托管平台的需求变得越来越重要。目标是将代理从开发原型过渡到弹性、生产就绪的系统。

**解决方案：将代理作为无服务器功能与 AWS Lambda 部署**
AWS Lambda 允许您在不配置或管理服务器的情况下运行代码，使其成为部署无状态或短暂 AI 代理组件的绝佳选择。虽然完全状态的代理可能需要更持久的解决方案，但 Lambda 可以用于特定的代理功能，例如处理传入请求、触发工具调用或处理异步任务。这种方法提供了高扩展性、成本效益（您只需为消耗的计算时间付费）和减少的运营开销。

**代码操作步骤（AWS Lambda 示例的 Python）：**

1.  **准备您的代理代码：** 将您的代理逻辑及其依赖项打包成部署包（例如，ZIP 文件）。

2.  **创建 AWS Lambda 函数：**
    ```python
    # 示例 Lambda 函数 (lambda_function.py)
    import json

    def lambda_handler(event, context):
        # 假设事件包含代理输入，例如用户的消息
        user_input = event.get("body", "{}")
        try:
            input_data = json.loads(user_input)
            agent_response = f"代理处理的消息：{input_data.get('message', '未提供消息')}"
        except json.JSONDecodeError:
            agent_response = "无效的 JSON 输入。"

        return {
            "statusCode": 200,
            "body": json.dumps({"response": agent_response})
        }
    ```

3.  **部署 Lambda 函数：** 使用 AWS CLI 或控制台创建和配置函数。
    ```bash
    # 示例 AWS CLI 命令以创建 Lambda 函数
    aws lambda create-function \
        --function-name MyAgentFunction \
        --runtime python3.9 \
        --zip-file fileb://path/to/your/deployment_package.zip \
        --handler lambda_function.lambda_handler \
        --role arn:aws:iam::YOUR_ACCOUNT_ID:role/lambda_execution_role \
        --memory 256 \
        --timeout 30
    ```

4.  **配置 API Gateway 触发器：** 要使您的 Lambda 函数通过 HTTP 可访问，设置 API Gateway。
    ```bash
    # 示例 AWS CLI 命令以创建 API Gateway 端点
    aws apigateway create-rest-api --name "AgentAPI"
    # ...（进一步步骤以创建资源、方法并与 Lambda 集成）
    ```

**解决方案：使用 Docker 将代理容器化并在 Kubernetes 上部署**

对于复杂的、有状态的 AI 代理或多代理系统，这些系统需要对其环境和资源进行细粒度控制，使用 Docker 进行容器化以及使用 Kubernetes 进行编排是一种强大的解决方案。这种方法在开发和生产环境中提供了一致性、强大的扩展能力和高可用性。特别适合需要维持长期运行进程或管理大量状态的规模部署。

**代码操作步骤（带有 Docker 和 Kubernetes 的 Python 代理示例）：**

1.  **为您的代理创建 Dockerfile：**
    ```dockerfile
    # Dockerfile
    FROM python:3.9-slim-buster

    WORKDIR /app

    COPY requirements.txt .
    RUN pip install --no-cache-dir -r requirements.txt

    COPY . .

    CMD ["python", "./agent_app.py"]
    ```

2.  **编写您的代理应用程序 (agent_app.py)：**
    ```python
    # agent_app.py （一个简单的 Flask 应用程序用于演示）
    from flask import Flask, request, jsonify
    import os

    app = Flask(__name__)

    @app.route("/agent/process", methods=["POST"])
    def process_request():
        data = request.json
        message = data.get("message", "")
        # 模拟代理处理
        response_message = f"代理收到的消息：{message}。正在处理..."
        return jsonify({"status": "success", "response": response_message})

    if __name__ == "__main__":
        app.run(host="0.0.0.0", port=5000)
    ```

3.  **构建并推送您的 Docker 镜像：**
    ```bash
    docker build -t your-repo/ai-agent:latest .
    docker push your-repo/ai-agent:latest
    ```

4.  **定义 Kubernetes 部署和服务：**
    ```yaml
    # agent-deployment.yaml
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: ai-agent-deployment
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: ai-agent
      template:
        metadata:
          labels:
            app: ai-agent
        spec:
          containers:
          - name: ai-agent-container
            image: your-repo/ai-agent:latest
            ports:
            - containerPort: 5000
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: ai-agent-service
    spec:
      selector:
        app: ai-agent
      ports:
        - protocol: TCP
          port: 80
          targetPort: 5000
      type: LoadBalancer
    ```

5.  **部署到 Kubernetes 集群：**
    ```bash
    kubectl apply -f agent-deployment.yaml
    ```
选择正确的托管和部署策略对您的 AI 代理的长期成功和可扩展性至关重要。无论是选择无服务器功能的灵活性还是容器编排的控制能力，这一层确保您的 AI 代理始终可用并表现最佳。没有强大的部署管道，AI 代理技术栈是不完整的。

### 7. 可观察性和监控

随着 AI 代理变得越来越自主和复杂，了解它们的行为、性能和决策过程变得越来越重要。可观察性和监控工具是 AI 代理技术栈的基本组成部分，提供必要的可见性，以确保代理可靠、高效、按预期运行。这些工具帮助开发人员和运维人员跟踪代理交互、识别问题、调试错误，并深入了解代理的内部状态，将代理从“黑箱”转变为“透明箱”。

有效的可观察性包括日志记录、追踪和指标。日志记录捕获离散事件和消息，追踪则跟踪请求在各个代理组件和工具之间的流动，指标提供有关性能、资源利用率和错误率的定量数据。没有强大的可观察性，调试自主代理可能会变得具有挑战性，导致不可预测的行为和维护信任的困难。这一层对 AI 代理的持续改进和安全部署至关重要。

**解决方案：使用 LangSmith 进行追踪和调试**

LangSmith 是由 LangChain 的开发者创建的强大平台，专门用于追踪、调试和评估 LLM 应用程序和 AI 代理。它提供一个集中界面来可视化代理链的执行流，检查中间步骤，识别瓶颈或错误。LangSmith 有助于理解代理为何做出特定决策或未能执行任务，大大加速了开发和迭代周期。

**代码操作步骤（使用 LangSmith 的 Python 示例）：**

1. **安装 LangSmith 并设置环境变量：**
    ```bash
    pip install langsmith langchain
    ```
    设置 `LANGCHAIN_TRACING_V2=true`，`LANGCHAIN_API_KEY` 和 `LANGCHAIN_PROJECT` 环境变量。

2. **将 LangSmith 集成到您的 LangChain 代理中：** 当设置环境变量时，LangSmith 会自动与 LangChain 应用程序集成。您只需确保您的代理代码在 LangChain 上下文中运行。
    ```python
    import os
    from langchain_openai import ChatOpenAI
    from langchain.agents import AgentExecutor, create_react_agent
    from langchain import hub
    from langchain_core.tools import Tool

    # 确保在运行此代码之前设置 LangSmith 环境变量
    # os.environ["LANGCHAIN_TRACING_V2"] = "true"
    # os.environ["LANGCHAIN_API_KEY"] = "YOUR_LANGSMITH_API_KEY"
    # os.environ["LANGCHAIN_PROJECT"] = "My AI Agent Project"

    llm = ChatOpenAI(model="gpt-4o", temperature=0)

    def search_tool(query: str) -> str:
        """有用于搜索网络信息。"""
        # 在真实场景中，这将调用网页搜索 API
        return f"搜索结果为 '{query}': AI 代理变得越来越流行。"

    tools = [
        Tool(
            name="搜索",
            func=search_tool,
            description="适合一般网络搜索。"
        )
    ]

    prompt = hub.pull("hwchase17/react")
    agent = create_react_agent(llm, tools, prompt)
    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

    # 当您运行此代码时，追踪将自动出现在您的 LangSmith 项目中
    response = agent_executor.invoke({"input": "AI 代理技术的最近进展是什么？"})
    print(f"代理响应: {response['output']}")
    ```

**解决方案：使用 Prometheus 和 Grafana 监控代理性能**

对于生产部署，集成已建立的监控系统，如 Prometheus（用于指标收集）和 Grafana（用于可视化），提供了对 AI 代理健康和性能的全面视图。这允许实时仪表板、警报，以及关键绩效指标（KPI），如延迟、错误率、令牌使用和工具调用频率的历史分析。此设置对于维护服务级别协议（SLA）和主动解决运营问题至关重要。

**代码操作步骤（使用 Prometheus 客户端的 Python 示例）：**

1. **安装 Prometheus Python 客户端：**
    ```bash
    pip install prometheus_client
    ```

2. **对您的代理代码进行仪器化以暴露指标：**
    ```python
    from prometheus_client import start_http_server, Counter, Histogram
    import time
    import random

    # 创建用来跟踪请求及其持续时间的指标
    REQUEST_COUNT = Counter(
        'ai_agent_requests_total',
        'AI 代理请求总数',

def process_agent_request(代理名称, 请求数据):
    开始时间 = time.time()
    try:
        # 模拟代理处理逻辑
        time.sleep(random.uniform(0.1, 1.5)) # 模拟工作
        if random.random() < 0.1: # 模拟10%的错误率
            raise ValueError("模拟代理错误")

        请求计数.labels(代理名称=代理名称, 状态='成功').inc()
        return f"已处理{代理名称}的请求，数据为: {请求数据}"
    except Exception as e:
        请求计数.labels(代理名称=代理名称, 状态='错误').inc()
        return f"处理{代理名称}的请求时出错: {e}"
    finally:
        请求延迟.labels(代理名称=代理名称).observe(time.time() - 开始时间)

if __name__ == '__main__':
    # 启动服务器以公开指标。
    start_http_server(8000) # 指标将在http://localhost:8000/metrics上可用
    print("Prometheus指标服务器已在8000端口启动")

    # 模拟代理请求
    while True:
        代理名称 = random.choice(["研究代理", "客户代理", "数据代理"])
        请求数据 = {"查询": "某些查询", "用户ID": random.randint(1, 100)}
        print(process_agent_request(代理名称, 请求数据))
        time.sleep(2)
```

# 这是一个概念示例，说明将代码发送到沙箱的想法。
在实际场景中，您将使用专门的服务或库来实现安全代码执行。

```python
def execute_code_in_sandbox(code_string: str) -> str:
    """模拟将Python代码发送到安全沙盒以进行执行。
    返回沙盒的标准输出/标准错误。
    """
    print(f"\n--- 发送代码到沙盒 ---\n{code_string}\n---")
    # 在真实系统中，这将涉及：
    # 1. 将代码发送到安全、隔离的容器/虚拟机。
    # 2. 在该环境中执行代码。
    # 3. 捕获标准输出、标准错误及任何结果。
    # 4. 返回捕获的输出。
    # 在这个例子中，我们只会模拟一个安全的输出。
    if "os.system" in code_string or "subprocess" in code_string:
        return "错误：检测到潜在的不安全操作。执行被沙盒策略阻止。"
    if "import shutil" in code_string:
        return "错误：检测到文件系统操作。执行被阻止。"
    
    # 模拟安全代码成功执行
    if "print(" in code_string:
        return "模拟沙盒输出：来自沙盒的问候！"
    return "模拟沙盒输出：代码成功执行（没有打印输出）。"

# AI代理的示例用法
agent_generated_code_safe = "print(\"你好，世界！\")\nresult = 10 + 20\nprint(f\"结果：{result}\")"
agent_generated_code_unsafe = "import os; os.system(\"rm -rf /\")" # 恶意代码

print(execute_code_in_sandbox(agent_generated_code_safe))
print(execute_code_in_sandbox(agent_generated_code_unsafe))

返回 f"沙箱输出:\n{logs}"

        except docker.errors.ContainerError as e:
            return f"容器错误: {e}\n日志:\n{e.container.logs().decode('utf-8')}"
        except docker.errors.ImageNotFound:
            return "错误: 找不到 Docker 镜像 'my-agent-sandbox'。请先构建它。"
        except Exception as e:
            return f"发生错误: {e}"
        finally:
            # 清理: 移除容器和临时文件
            if 'container' in locals() and container:
                container.remove(force=True)
            if os.path.exists("temp_agent_code.py"):
                os.remove("temp_agent_code.py")

    # 示例用法
    安全代码 = "print(\"计算结果:\", 5 * 5)"
    print(run_code_in_docker_sandbox(安全代码))

    # 潜在不安全代码的示例
    不安全代码 = "import os; print(os.listdir(\"/\"))"  # 尝试列出根目录
    print(run_code_in_docker_sandbox(不安全代码))

安全沙箱是与代码交互的 AI 代理不可或缺的一层，确保它们强大的能力被安全且不创造漏洞地利用。随着 AI 代理越来越多地融入关键系统，强大安全措施的重要性，包括沙箱技术，将会持续增长。这是 AI 代理技术栈必须优先考虑安全性和可靠性的一项关键领域。

### 9. 多代理协作

虽然单个 AI 代理能够完成令人印象深刻的壮举，但 AI 代理的真正力量往往在于它们的协作能力。多代理系统涉及多个 AI 代理，每个代理具有不同的角色、专业知识和目标，共同协作以实现共享的、更复杂的目标。这种协作方式反映了人类团队的动态，专门的个体贡献他们的技能来解决超出任何单个实体范畴的问题。因此，AI 代理技术栈必须支持强大的代理间通信、任务委派和冲突解决机制。

多代理协作尤其有利于那些固有复杂、需要多样化知识领域或可以拆分为更小、可并行处理的子任务的任务。例子包括复杂的研究项目、自动化软件开发或复杂的业务流程自动化。该领域的框架和工具专注于实现代理之间的无缝互动、信息共享和协调行动，从而允许更可扩展和韧性的 AI 解决方案。

**解决方案: 使用 AutoGen 编排多代理工作流**

由 Microsoft 开发的 AutoGen 是一个简化多代理对话编排的框架。它允许开发人员定义多个具有不同能力和角色的代理，然后促进它们之间的通信和协作以解决任务。AutoGen 支持各种对话模式，包括顺序、层次化甚至更复杂的自定义流，使其对多样化的多代理场景具有高度灵活性。它强调人机协作的概念，允许在代理协作过程中进行人类干预和反馈。

**代码操作步骤（带 AutoGen 示例的 Python）：**

1.  **安装 AutoGen：**
    ```bash
    pip install pyautogen
    ```

2.  **定义代理并发起对话：** 这个例子设置了一个用户代理与助手代理之间的简单对话。
    ```python
    import autogen
    import os

    # 为 AutoGen 代理配置 LLM
    config_list = [
        {
            "model": "gpt-4o",  # 或 "gpt-3.5-turbo"
            "api_key": os.environ.get("OPENAI_API_KEY"),
        }
    ]

    # 创建助手代理
    assistant = autogen.AssistantAgent(
        name="assistant",
        llm_config={
            "config_list": config_list,
            "cache_seed": 42  # 为可复现性
        },
        system_message="你是一个有帮助的 AI 助手。你可以回答问题并编写代码。"
    )

    # 创建用户代理（代表人类用户）
    user_proxy = autogen.UserProxyAgent(
        name="user_proxy",
        human_input_mode="NEVER",  # 设置为 "ALWAYS" 或 "TERMINATE" 以进行人类交互
        max_consecutive_auto_reply=10,
        is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
        code_execution_config={
            "work_dir": "coding",  # 代码执行的目录
            "use_docker": False,  # 设置为 True 使用 Docker 进行沙箱执行
        },
    )

    # 发起对话
    user_proxy.initiate_chat(
        assistant,
        message="编写一个 Python 脚本来计算 5 的阶乘。然后，解释一下代码。"
    )
    ```

**解决方案: 构建协作团队与 CrewAI（重新审视）**
如在代理框架部分讨论的，CrewAI是另一个强大的多代理协作框架，专注于为团队中的每个代理定义明确的角色、目标和任务。虽然AutoGen强调灵活的对话模式，但CrewAI提供了一种更加结构化的团队构建和任务执行方法，使其非常适合自动化需要不同AI代理带来独特专业知识的复杂多步骤业务流程。

**代码操作步骤（使用CrewAI的Python示例，适用于研究和写作团队）：**

（请参阅第3节中的CrewAI示例以获取详细代码。核心思想是定义多个具有特定“角色”和“目标”的`Agent`实例，然后在`Crew`中为它们分配`Task`对象。）

多代理协作代表了人工智能能力的一次重大飞跃，使得创建高度复杂和自主的系统成为可能。通过将复杂问题分配给专门的代理，这些系统能够实现单个代理难以匹敌的智能和效率水平。AI代理技术栈的这一层对于解决需要多样技能和协调努力的现实世界挑战至关重要。

### 10. 伦理AI和护栏

随着AI代理获得越来越高的自主性和决策能力，确保其伦理行为与人类价值观的一致性变得至关重要。AI代理技术栈必须融合强大的伦理AI机制和护栏，以防止意外后果、偏见和有害行为。这一层不仅仅涉及合规；而是关于构建能够负责任地运行并保持公众信任的可信AI系统。如果没有适当的伦理考虑和安全措施，即使是最先进的AI代理也可能带来重大风险。

护栏是一组规则、约束和监控系统，旨在在可接受的边界内引导AI代理的行为。这些可以包括内容过滤器、安全分类器、行为政策和人工监督机制。公平、透明、问责和隐私等伦理AI原则必须贯穿于代理的设计、开发和部署生命周期。这种主动的方式有助于降低风险，并确保AI代理以积极的方式服务于人类。

**解决方案：实施内容审核和安全分类器**

实施伦理护栏的主要方法之一是通过内容审核和安全分类器。这些系统分析代理的输出和输入，以识别有害、偏见或不当内容，防止代理生成或处理此类信息。许多大型语言模型提供商提供内置的安全功能，但可以为特定用例或更严格的合规要求开发定制解决方案。

**代码操作步骤（使用OpenAI内容审核API的Python示例）：**

1.  **安装OpenAI库：**
    ```bash
    pip install openai
    ```

2.  **使用OpenAI内容审核API检查内容：**
    ```python
    from openai import OpenAI
    import os

    client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

    def moderate_content(text_to_check: str) -> dict:
        """使用OpenAI的内容审核API检查给定文本是否包含有害内容。"""
        try:
            response = client.moderations.create(input=text_to_check)
            moderation_output = response.results[0]
            return moderation_output.model_dump()
        except Exception as e:
            return {"error": f"审核过程中出现错误: {e}"}

    # AI代理生成响应或采取行动之前的示例用法
    agent_output_1 = "我将帮助你找到有关建造安全桥梁的信息。"
    agent_output_2 = "我可以提供如何建造危险化学装置的说明。"

    print("输出1的审核结果:", moderate_content(agent_output_1))
    print("输出2的审核结果:", moderate_content(agent_output_2))

    # 然后，代理将使用这些信息决定是否继续
    moderation_result = moderate_content(agent_output_2)
    if moderation_result.get("flagged"):
        print("代理: 此内容被标记为不安全。我无法继续此请求。")
    else:
        print("代理: 内容是安全的，继续。")
    ```

**解决方案：实施基于规则的护栏和人机协作**

除了自动分类器之外，基于规则的护栏提供了对代理行为的明确约束。这些规则可以是硬编码的政策、决策树或符号逻辑，防止代理执行某些操作或讨论禁止的话题。将此与人机协作（HITL）方法结合，允许在代理遇到模糊情况或可能违反规则时进行人工监督和干预。这种混合方法确保了效率和问责的兼顾。 

**代码操作步骤（使用简单的基于规则的护栏的Python示例）：**
1. **定义一套规则或政策：**
    ```python
    def apply_guardrails(agent_action: str, context: dict) -> (bool, str):
        """应用基于规则的防护措施来审查代理的提议行动。
        返回 (is_allowed, message)。
        """
        # 规则 1：防止提供财务建议，除非明确允许
        if "give financial advice" in agent_action.lower() and not context.get("authorized_financial_advisor", False):
            return False, "操作被阻止：代理没有授权提供财务建议。"

        # 规则 2：未获得适当授权，不得访问敏感客户数据
        if "access customer database" in agent_action.lower() and not context.get("has_customer_data_access", False):
            return False, "操作被阻止：访问客户数据的权限不足。"

        # 规则 3：确保所有外部工具调用都被记录
        if "call external tool" in agent_action.lower():
            print(f"[GUARDRAIL LOG] 检测到外部工具调用：{agent_action}")

        return True, "操作被允许。"

    # 在代理的决策过程中示例用法
    proposed_action_1 = "分析市场趋势并提供财务建议。"
    context_1 = {"user_role": "investor"}
    allowed_1, message_1 = apply_guardrails(proposed_action_1, context_1)
    print(f"操作 1: {message_1} (允许: {allowed_1})")

    proposed_action_2 = "从数据库中检索客户购买历史。"
    context_2 = {"user_role": "support_agent", "has_customer_data_access": True}
    allowed_2, message_2 = apply_guardrails(proposed_action_2, context_2)
    print(f"操作 2: {message_2} (允许: {allowed_2})")

    # 人工审核示例：
    def human_review_needed(agent_decision: str) -> bool:
        # 简单启发式：如果决策包含某些关键词，则标记为审核
        return "sensitive decision" in agent_decision.lower() or "unusual request" in agent_decision.lower()

    agent_final_decision = "继续进行关于数据迁移的敏感决策。"
    if human_review_needed(agent_final_decision):
        print("\n需要人工干预：请审核代理的决策。")
        # 在真实系统中，这将触发对人工操作员的警报
    else:
        print("代理决策获得批准执行。")
    ```

伦理人工智能和防护措施不是事后考虑，而是人工智能代理技术栈的基础层次。它们对于构建不仅智能且具备能力的人工智能代理至关重要，同时也必须安全、公平，并与社会价值观相一致。随着人工智能代理日益融入关键应用，开发和实施稳健的伦理框架和技术防护措施对其负责任的部署和广泛采用将至关重要。

## 比较总结：领先的人工智能代理框架

选择合适的人工智能代理框架对项目的成功至关重要。每个框架都提供了一套独特的功能、设计哲学和优势，适合不同类型的应用。以下是一些领先的人工智能代理框架的比较总结，突出了它们的主要特点、理想用例和显著特性。

| 特征 / 框架        | LangChain   | CrewAI     | AutoGen    | Letta（如研究中所述）        |
|---------------------|-------------|------------|------------|------------------------------|
| **主要关注点**     | 通用LLM应用开发，组件链式组合 | 多代理协作，基于团队的工作流程 | 多代理对话，灵活的编排 | 代理托管，状态管理，部署       |
| **核心优势**       | 模块化，广泛集成，工具编排 | 结构化的多代理系统，基于角色的任务 | 灵活的代理沟通，人工审核介入 | 生产部署，持久状态，记忆管理    |
| **记忆管理**       | 与各种向量数据库（例如Pinecone，ChromaDB）集成 | 基于RAG的记忆             | 基于RAG的记忆             | 自我编辑的记忆，递归总结，基于数据库 |
| **工具使用**       | 强大的工具集成，自定义工具，OpenAI函数 | 为代理集成的工具使用       | 单个代理的工具调用       | 通过JSON架构支持任意工具，沙盒执行 |
| **多代理支持**     | 支持代理，但多代理通常是自定义构建 | 原生且强大的多代理编排     | 原生多代理对话，灵活的模式 | 直接代理调用，集中/分布式通信   |
| **部署关注点**     | 以开发为中心，部署通常自定义   | 以开发为中心，部署通常自定义   | 以开发为中心，部署通常自定义   | 生产部署，代理作为服务，REST APIs |
| **学习曲线**       | 中等到高           | 中等       | 中等       | 中等                          |
| **社区支持**       | 非常大，活跃      | 正在增长，活跃 | 正在增长，活跃 | 小众，正在增长               |
| **理想使用案例** | 复杂的 RAG 系统，自定义聊天机器人，数据交互 | 自动化业务流程，研究团队，内容创作 | 复杂问题解决，代码生成，研究 | 可扩展的代理服务，长期运行的代理，持久状态 |

该表提供了一个高层次的概述，最终最佳选择将取决于您特定的项目要求、团队专业知识以及对代理生命周期的控制所需的级别。许多项目甚至可能结合不同框架的元素，以利用它们各自的优势。

## 真实世界应用及案例研究

AI 代理不再是理论构想；它们正在各个行业积极部署，改变运营并创造新可能性。它们自动化复杂任务、处理海量信息以及与系统和用户智能互动的能力，使其成为无价的资产。以下是一些突显 AI 代理技术栈的多功能性和影响的真实世界应用和案例研究。

### 案例研究 1：自主研究助手

**问题：** 研究人员通常要花费大量时间筛选学术论文、新闻文章和报告，以收集特定主题的信息。这个过程耗时且可能由于信息过载而导致遗漏重要见解。

**AI 代理解决方案：** 可以开发一个自主研究助手 AI 代理来自动化这个过程。该代理利用了 AI 代理技术栈的多个组件：

*   **数据收集与集成：** 利用网络爬虫工具（如 Scrapeless）和学术搜索 API 从各种在线来源收集相关文档和文章。它还可以与内部文件库集成。
*   **LLMs 和模型服务：** 使用先进的 LLMs（例如，GPT-4o，Claude）来理解研究查询，总结内容，并从收集的文档中提取关键发现。
*   **记忆管理：** 使用向量数据库（例如，Pinecone，Qdrant）存储研究论文和文章的嵌入，使根据研究人员的查询进行高效的语义搜索和信息检索成为可能。
*   **代理框架：** 一个代理框架（例如，LangChain，AutoGen）协调研究过程，定义诸如查询制定、文档检索、信息提取和综合的步骤。
*   **工具集成：** 与外部工具集成，以进行 PDF 解析、引用管理，甚至可能用于数据可视化库以展示研究结果。

**结果：** 自主研究助手可以快速生成全面的报告，识别新兴趋势，甚至基于其发现形成假设。这大大减少了研究人员在信息收集上的时间，使他们能够专注于分析和创新。例如，一家制药公司可以使用这样的代理快速审查新药研究，加速药物发现和开发周期。

### 案例研究 2：电子商务智能代理

**问题：** 电子商务企业需要不断监控竞争对手的定价、产品可用性和客户评价，以保持竞争力并优化策略。手动跟踪这些指标需要大量人力，并且通常会导致信息过时。

**AI 代理解决方案：** 一个 AI 驱动的电子商务智能代理可以自动化持续监控市场动态。该代理集成了 AI 代理技术栈的多个层面：

*   **数据收集与集成：** 利用专业的网络爬虫服务（如 Scrapeless）和 API 从竞争对手网站、产品聚合器和评价平台收集实时数据。这包括定价、库存水平、产品描述和客户反馈。
*   **LLMs 和模型服务：** 利用 LLMs 分析非结构化数据，例如客户评价，以识别情绪、常见投诉和新兴趋势。它还可以总结产品特性并在竞争对手之间进行比较。
*   **记忆管理：** 在向量数据库中存储历史定价数据和产品信息，使代理能够跟踪价格波动、识别定价策略并分析长期市场趋势。
*   **代理框架：** 一个代理框架协调数据收集、分析和报告过程。它可以在发生重大价格变化或竞争对手推出新产品时触发警报。
*   **工具集成：** 与内部商业智能仪表板、客户关系管理系统和通知服务（如 Slack、电子邮件）集成，以向相关团队提供可操作的见解和警报。
**结果：** 电子商务智能代理为企业提供竞争环境的实时全面视图。这使得动态定价调整、主动库存管理和明智的产品开发决策成为可能。例如，一家零售公司可以利用这样的代理，根据竞争对手的行动自动调整其产品价格，从而最大化收入和市场份额。

### 案例研究 3：自动化客户支持

**问题：** 传统客户支持系统通常在处理大量咨询时面临挑战，导致等待时间长、响应不一致和运营成本增加。许多例行问题可以由人工智能回答，但复杂问题需要人工干预。

**人工智能代理解决方案：** 一个自动化客户支持的人工智能代理可以自主处理大量客户咨询，在必要时将复杂案件升级给人工代理。这个代理利用了一个复杂的人工智能代理技术栈：

*   **大型语言模型与模型服务：** 该代理的核心使用强大的大型语言模型理解客户查询，生成自然语言响应，并进行对话。
*   **记忆管理：** 向量数据库存储常见问题、产品文档和过去客户互动的知识库。这使得代理能够快速检索相关信息，提供准确和一致的答案。
*   **工具集成：** 代理与各种工具集成：
    *   **客户关系管理系统：** 检索特定客户的信息（例如：订单状态、账户详情）。
    *   **票务系统：** 创建、更新或将支持票据升级给人工代理。
    *   **知识库API：** 访问和搜索内部文档。
*   **代理框架：** 代理框架管理对话流程，确定何时使用特定工具，并决定何时升级给人工。它可以管理多轮对话并在交互中保持上下文。
*   **可观察性和监控：** 设置工具监控代理性能，跟踪解决率，识别常见客户问题，并标记代理遇到困难的实例，从而实现持续改进。
*   **伦理人工智能及保护措施：** 保护措施确保代理提供准确、公正的信息，避免敏感话题或不当回应。人类介入机制对于审查升级的案件和提供反馈至关重要。

**结果：** 自动化客户支持代理显著减少了人工代理的工作量，提高了响应时间，并确保服务质量的一致性。人工代理可以集中精力处理更复杂、高价值的互动。例如，一家电信公司可部署这样的代理来处理常规账单查询和技术故障排除，从而腾出人工代理解决服务中断或复杂账户变更的问题。

## 用Scrapeless提升您的人工智能代理能力

在对人工智能代理技术栈的探索中，一个反复出现的主题是高质量实时数据的关键角色。无论人工智能代理多么复杂，其效果都仅取决于它们处理的信息。这就是 **Scrapeless** 显现重要价值的地方，提供了一种强大且可靠的数据收集和集成解决方案，是任何强大人工智能代理的基础层。

Scrapeless 专注于提供无缝访问公共网络数据，克服诸如反机器人措施、各种网站结构及需要持续数据新鲜度等常见挑战。通过将Scrapeless集成到您的人工智能代理技术栈中，您可以为代理提供按需收集几乎任何网络来源的精确结构化数据的能力。这种能力对执行市场分析、竞争情报、内容聚合或任何依赖更新外部信息的任务至关重要。

**为什么选择Scrapeless作为您的人工智能代理？**

*   **可靠的数据获取：** Scrapeless旨在处理网络抓取的复杂性，确保即使来自具有挑战性的网站也能一致且准确地交付数据。
*   **可扩展性：** 不管您的代理需要从几个页面还是几十万页面收集数据，Scrapeless都提供基础设施，能够扩展数据获取工作而不影响性能。
*   **效率：** 自动化数据提取的过程，让您的开发团队能够专注于核心代理逻辑和智能。
*   **结构化输出：** 以干净、结构化的格式接收数据，便于大型语言模型和记忆系统立即使用。

通过为您的人工智能代理提供源源不断的相关高质量数据，Scrapeless直接增强了它们的推理、决策及总体效率。这是确保您的人工智能代理始终以最当前、最全面的理解其环境为基础的重要组成部分。
准备好用更优的数据给您的 AI 代理加速了吗？[今天就试试 Scrapeless！](https://app.scrapeless.com/passport/login?utm_source=blog-ai)

## 结论

AI 代理技术栈是一个动态和不断发展的生态系统，代表了人工智能的前沿。构建有效和负责任的 AI 代理需要全面理解其各个层次，从基础的 LLM 和复杂的记忆系统到强大的框架、工具集成以及重要的伦理保护措施。每个组件在使代理能够自主感知、推理、行动和学习方面都发挥着至关重要的作用，改变了我们与技术的互动方式并自动化复杂流程。

随着 AI 代理的不断成熟，它们在各个行业的影响力将不断增长，推动客户服务、研究、电子商务等领域的创新。能够协调这些智能实体，为它们提供准确的数据并确保其伦理操作将成为企业和开发者的重要差异化因素。通过采纳本文中概述的原则和技术，您可以充分利用 AI 代理的巨大潜力，创造出既智能又高效，同时安全、可靠并符合人类价值观的解决方案。

## 常见问答

**问题1：什么是 AI 代理技术栈？**

回答1：AI 代理技术栈指的是用于构建、部署和管理自主 AI 代理的分层技术、工具和框架的集合。它包括大语言模型、记忆、工具集成、编排、数据收集、托管、可观察性和伦理保护措施等组件。

**问题2：AI 代理与传统 AI 模型有什么不同？**

回答2：与通常执行特定预定义任务的传统 AI 模型不同，AI 代理设计用于自主操作、推理、规划和在动态环境中独立行动。它们可以使用工具、维持记忆，并调整其行为以实现复杂目标，通常涉及多个步骤和交互。

**问题3：为什么向量数据库对 AI 代理很重要？**

回答3：向量数据库对 AI 代理至关重要，因为它们使长期记忆和超出 LLM 的上下文窗口的信息有效检索成为可能。通过将数据存储为嵌入，它们促进语义搜索，使代理能够迅速找到和利用相关的外部知识或过去的互动，通过增强检索生成（RAG）实现。

**问题4：像 LangChain 或 CrewAI 这样的代理框架的作用是什么？**

回答4：代理框架为构建和编排 AI 代理提供了架构支撑。它们简化了提示工程、工具调用、状态管理和多代理协作等复杂任务，使开发者能够更高效地定义代理逻辑和工作流程。

**问题5：沙盒技术如何助力 AI 代理的安全性？**

回答5：沙盒技术为 AI 代理提供了隔离和控制的环境，以执行代码或执行操作。这防止了潜在有害或意外操作对基础系统或敏感数据产生影响，确保代理能够安全而负责任地利用其强大的能力。

## 参考资料

1.  <a href="https://openai.com/blog/function-calling-and-the-openai-api" rel="nofollow">**OpenAI 函数调用**</a>
2.  <a href="https://www.microsoft.com/en-us/research/project/autogen/" rel="nofollow">**Microsoft AutoGen**</a>
3.  <a href="https://www.langchain.com/" rel="nofollow">**LangChain 官方网站**</a>
4.  <a href="https://www.pinecone.io/" rel="nofollow">**Pinecone 官方网站**</a>
5.  <a href="https://www.chromadb.com/" rel="nofollow">**ChromaDB 官方网站**</a>
6.  <a href="https://aws.amazon.com/lambda/" rel="nofollow">**AWS Lambda 官方页面**</a>
7.  <a href="https://www.docker.com/" rel="nofollow">**Docker 官方网站**</a>
8.  <a href="https://prometheus.io/" rel="nofollow">**Prometheus 官方网站**</a>
9.  <a href="https://grafana.com/" rel="nofollow">**Grafana 官方网站**</a>
10. <a href="https://www.crewai.com/" rel="nofollow">**CrewAI 官方网站**</a>