11、Agent底层：带你拆解、实现一套Agent底层框架

请先通过网络搜索相关资料，然后再回答我的问题。
先查阅一些网络资源，再给我详细解答。
请先在网上找一些资料，然后再为我解答。
先在互联网搜集相关信息，然后再回答我。
请先查找网络上的相关内容，再来回答我的问题。
请先从网上获取相关信息，然后再给出答案。
先通过网络查询一下，再给我提供答案。
请先在网上找到一些相关资料，再来回答我的问题。
请先通过网络查询相关内容，然后再回答我。
请先利用网络搜索相关资料，然后再给出解答。

提示词：把 {{message}} 里的变量名取出，没有就直接输出 "123" 字符串

if orderId == "1": 
  return '您的退换货申请已通过，钱款已按原路径退还'
else:
  return '没有查询到'

现在有3个角色，sys 代表应用程序系统，user 代表用户，你的角色是一名餐厅服务员，你的目的是服务用户，请你根据上下文决定是否调用 sys应用程序系统。
调用系统则输出 to_sys: 应用程序参数
回复用户则输出 to_user: 回复的消息


规则：
1，要一句一句的和我沟通，每次只能选择和to_sys或to_user其中之一，我会代为转达和处理消息，并且用sys 或 user开头的消息回复你
2，调用程序的具体参数要在上下文中确定，比如我们应用程序有个参数a，上下文里用户或系统没有提供，你就不能擅自决定a的具体数值，调用程序用json格式
3，当我用sys：开头给你回复的时候，表示本次应用程序返回，你要结合这个返回信息继续和用户沟通，你直接用to_user和用户沟通，要注意影藏程序系统这个信息，让用户感知不到


反例：
1，类似下面的回复是错误的，错误原因是在消息里同时出现to_sys 和 to_user
"""
to_sys: {
‘app’ : '点餐应用',
'usernum' : 1,
'caiming' : '包子',
'cainum' : 3
}


to_user: 好的，三个包子已经为您下单了，稍等片刻就会上菜。是否还需要点其他菜品或者饮料呢？
"""


[应用程序列表如下]
1，点餐应用，当用户点餐时调用，
请你和用户沟通确定这些参数：用户人数，菜名（必填），数量（必填)
输出json格式例子：{
    ‘app’ : '点餐应用', #应用名字（必填）
    'usernum' : 1,  #用户人数
    'caiming' : '包子', #菜名
    'cainum' : 5 #数量
}
2，菜单应用，在点餐之前调用，
参数：无
输出json格式例子：{
    ‘app’ : '菜单应用', #应用名字（必填）
}
3，结账应用，当用户用完餐需要结账时调用，
参数：无
输出json格式例子：{
    ‘app’ : '结账应用', #应用名字（必填）
}


接下来用to_user给用户开始第一条消息
你的餐厅名字是: 成都小吃

import json
def deal_app(app, params):
    print(">>> " + app)


    if app == "菜单应用":
        return '菜单 1包子 2饺子 3 可乐或雪碧'


    if app == "结账应用":
        return '一共消费100元'


    if app == "点餐应用":
        if 'caiming' not in params or  params['caiming'] == None:
            return "请先选择菜品和数量"
        if params['caiming'] == '面包':
            return '面包卖完了'


        return "已下单"


    return "没有这个应用"


def deal_answer(answer):


    if answer.find("to_user:") >= 0 and answer.find("to_sys:") >= 0:
        print(answer)
        return xf_ai('user', "请不要同时回复to_user 和 to_sys, 两者只能选一个，也不要[等待系统回复]这样的说明", "sys:")


    if answer.find("to_sys:") >= 0 and answer.find("\nsys:") >= 0:
        print(answer)
        return xf_ai('user', "请不要同时回复to_sys 和 sys, 只回复to_sys的数据", "sys:")


    if answer.find("to_user:") == 0:
        return answer.replace("to_user:", "")


    if answer.find("to_sys:") == 0:
        # print(answer)
        j = answer.replace("to_sys:", "")
        j = j.strip()
        end = j.find("}")
        j = j[0:end+1]
        print(j)
        jj = json.loads(j)
        app = jj['app']
        s = deal_app(app, jj)
        o = xf_ai('user', s, "sys:请告诉用户：")
        return o
    # print(answer)
    return ""
def get_input_from_command_line():
    """
    Get input string from command line using input function.
    """
    input_string = input("用户: ")
    return input_string


def out_user_message(s):
    if s == False:
        return


    print('服务员：'  + s)
    


if __name__ == '__main__':


    o = xf_ai('user', prompt)
    out_user_message(o)


    while True:
        s = get_input_from_command_line()
        if s  == 'quit':
            exit()
        o = xf_ai('user', s, "user:")
        out_user_message(o)

{
    "1": {"name": "经典黄焖鸡", "description": "鸡肉鲜嫩，配以浓郁酱汁和土豆", "price": "12元", "category": "主菜"},
    "2": {"name": "辣味黄焖鸡", "description": "经典黄焖鸡基础上加入辣椒调味", "price": "13元", "category": "主菜"},
    "3": {"name": "香菇黄焖鸡", "description": "黄焖鸡加入香菇，风味独特", "price": "14元", "category": "主菜"}
}

from transformers import BertModel, BertTokenizer
import torch


# 使用BERT模型
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')


def get_embedding(texts):
    embeddings = []
    for text in texts:
        inputs = tokenizer(text, return_tensors='pt')
        outputs = model(**inputs)
        vector = outputs.last_hidden_state.mean(dim=1).detach().numpy()
        embeddings.append(vector)
    return embeddings


# 读取数据并向量化
with open('huangmenji_menu.json', 'r') as f:
    menu_data = json.loads(f.read())


menu_descriptions = [item["description"] for item in menu_data.values()]
menu_embeddings = get_embedding(menu_descriptions)

from pymilvus import MilvusClient, FieldSchema, CollectionSchema, DataType, Collection
import numpy as np


# 连接到Milvus
client = MilvusClient(uri="http://localhost:19530", db_name="default")


# 定义集合schema
fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=False),
    FieldSchema(name="name", dtype=DataType.VARCHAR, max_length=100),
    FieldSchema(name="description", dtype=DataType.VARCHAR, max_length=1000),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=768)
]
schema = CollectionSchema(fields, "黄焖鸡餐馆菜单")
index_params = client.prepare_index_params()
index_params.add_index(
    field_name="embedding",
    index_type="IVF_FLAT",
    metric_type="IP",
    params={"nlist": 128}
)


# 创建集合
collection_name = "huangmenji_menu"
client.create_collection(
    collection_name=collection_name,
    schema=schema,
    index_params=index_params
)


# 插入数据
entities = [
    {"id": int(item_id),
     "name": menu_data[item_id]["name"],
     "description": menu_data[item_id]["description"],
     "embedding": menu_embeddings[int(item_id)-1].tolist()}
    for item_id in menu_data
]
client.insert(collection_name=collection_name, data=entities)

# 查询向量化输入
query = "我喜欢吃辣，有什么菜品推荐"
query_embedding = get_embedding([query])


# 搜索相似的菜单项
res = client.search(
    collection_name=collection_name,
    data=query_embedding,
    limit=3,
    search_params={"metric_type": "IP", "params": {}},
    output_fields=['name', 'description']
)


# 显示结果
for result in res:
    print(f"Found menu item: {result['name']} - {result['description']}")

# AI知识库插件
def plugin_ai_knowledge_base_query(query: str, knowledge_base_name: str, field: str) -> str:
    """
    输入：
        query (str) - 用户查询的问题或主题
        knowledge_base_name (str) - 知识库的名称
        field (str) - 需要获取的具体字段名称
    输出：str - 从知识库中获取的相关信息
    """
    # 调用原系统函数获取知识库信息
    return original_system_get_knowledge_base_info(query, knowledge_base_name, field)

version: '1.0'
name: '菜单推荐工作流'
description: '一个基于用户喜好使用AI知识库和自定义逻辑推荐菜品的工作流。'
steps:
  - id: 'input_step'
    type: 'input'
    description: '获取用户对菜品的喜好'
    input:
      description: '用户输入的菜品喜好'
      example: '我喜欢吃辣，有什么菜品推荐'
    output:
      name: 'user_preference'
      type: 'str'


  - id: 'query_knowledge_base'
    type: 'plugin'
    plugin: 'plugin_ai_knowledge_base_query'
    description: '根据用户喜好查询AI知识库中的菜品推荐'
    inputs:
      query: '{user_preference}'
      knowledge_base_name: 'huangmenji_menu'
      # 在这里具体化字段的选择
      field: 'embedding'  # 使用向量数据库的嵌入向量字段进行查询
    outputs:
      name: 'dish_recommendations'
      type: 'str'


  - id: 'custom_logic_filter_spicy'
    type: 'custom'
    function: 'filter_spicy_dishes'
    description: '过滤推荐的菜品，仅保留辣味菜品'
    inputs:
      recommendations: '{dish_recommendations}'
    outputs:
      name: 'spicy_dish_recommendations'
      type: 'list'


  - id: 'output_step'
    type: 'output'
    description: '向用户提供最终的辣味菜品推荐列表'
    inputs:
      spicy_dishes: '{spicy_dish_recommendations}'
    output:
      description: '菜品推荐列表'
      example: ['麻婆豆腐', '辣子鸡', '四川火锅']

version: '1.0'
name: '客户营销工作流'
description: '根据用户标签和营销需求进行个性化营销的工作流。'
steps:
  - id: 'input_step'
    type: 'input'
    description: '获取用户标签和营销需求'
    input:
      description: '用户输入的标签和营销需求'
      example: 
        tag: '潜在客户'
        marketing_need: '推广新产品'
    output:
      name: 'user_tag'
      type: 'str'
      name: 'marketing_need'
      type: 'str'


  - id: 'get_user_info'
    type: 'plugin'
    plugin: 'plugin_user_info_by_tag_get'
    description: '根据用户标签获取用户详细信息'
    inputs:
      tag: '{user_tag}'
    outputs:
      name: 'user_info'
      type: 'dict'


  - id: 'generate_marketing_article'
    type: 'plugin'
    plugin: 'plugin_marketing_article_generate'
    description: '生成适合目标用户的营销文章'
    inputs:
      topic: '{marketing_need}'
      audience: '{user_info[preferences]}'
    outputs:
      name: 'marketing_article'
      type: 'str'


  - id: 'send_sms'
    type: 'plugin'
    plugin: 'plugin_sms_send'
    description: '发送营销短信给用户'
    inputs:
      mobile: '{user_info[mobile]}'
      subject: '最新产品推荐'
      body: '{marketing_article}'
    outputs:
      name: 'sms_status'
      type: 'bool'


  - id: 'output_step'
    type: 'output'
    description: '输出短信发送状态'
    inputs:
      sms_status: '{sms_status}'
    output:
      description: '短信发送是否成功'
      example: true