基于Llama 3的AI代理開發實戰演練

作者：朱先忠 2024-08-07 08:32:30

通過本文，您將學會基于開源的深度學習模型可視化工具Gradio構建一個具有Llama 3模型函數調用功能的AI代理的完整過程。

譯者 | 朱先忠

審校 | 重樓

簡介

想象一下，你想買點東西。于是，你訪問某個電子商務網站并使用搜索選項查找所需內容。也許你有很多東西要買，所以這個過程不是很有效。現在，請考慮一下這樣一個場景：打開一個應用程序，用簡單的英語描述一下你想要的東西，然后按下回車鍵。你不必擔心搜索和價格比較，因為應用程序會自動為你處理了。很酷，對吧？這正是我們將在本文中要構建的目標程序。

下面，先讓我們先看一些例子。

用戶同時請求多個產品

用戶咨詢他/她能做出的最劃算的購買

接下來，讓我們為這個應用程序增強一些功能。我們將使用Meta公司開發的具有函數調用功能的Llama 3開源模型。不過，本文示例程序也可以使用此模型的3.1版本來實現。根據Meta公司的公告（https://ai.meta.com/blog/meta-llama-3-1/），3.1版本模型可以更有效地使用工具和函數。

【注意】這些模型是支持多語言的，具有128K的更長的上下文長度和最先進的工具使用能力和整體更強的推理能力。

我將在本文示例開發中使用Groq云平臺，特別是他們在本文中的大數據模型。此應用程序的初始工作流程包括一個嵌入模型、一個檢索器，還有兩個主要工具，用于處理用戶購買興趣和與成本相關的問題。總之，我們需要類似于下圖所述的組件內容。

示例應用程序架構圖

現在，我們必須要在開發中選擇使用一個LLM組件框架。為此，我選擇了我一直最喜歡的生產級開源AI平臺框架Haystack（https://haystack.deepset.ai/）。

準備好了我們需要的內容后，接下來就讓我們開始投入關鍵的開發工作吧！

加載和索引數據

由于我們本示例程序中使用了一個RAG管道，我們首先構建一個文檔索引服務，將使用Haystack提供的內存向量數據庫。請注意，我們矢量數據庫中的每個文檔都包含如下字段：

內容（Content）——我們用來執行相似性搜索的內容
Id——唯一標識符
價格（Price）——產品價格
URL——產品URL

當調用我們的RAG管道時，Content字段用于向量搜索。所有其他字段都作為元數據包含在矢量數據庫中。注意，保存這些元數據是至關重要的，因為它們在用戶的前端演示中至關重要。

接下來，讓我們看看如何實現這一點。

from haystack import Pipeline, Document
from haystack.document_stores.in_memory import InMemoryDocumentStore
from haystack.components.writers import DocumentWriter
from haystack.components.embedders import SentenceTransformersDocumentEmbedder
from haystack.components.generators import OpenAIGenerator
from haystack.utils import Secret
from haystack.components.generators.chat import OpenAIChatGenerator
from haystack.components.builders import PromptBuilder
from haystack.components.embedders import SentenceTransformersTextEmbedder
from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever
from haystack.dataclasses import ChatMessage
import pandas as pd

#從CSV加載產品數據
df = pd.read_csv("product_sample.csv")

#初始化內存中的文檔存儲區
document_store = InMemoryDocumentStore()

#將產品數據轉換為Haystack文檔對象
documents = [
Document(
content=item.product_name, 
meta={
"id": item.uniq_id, 
"price": item.selling_price, 
"url": item.product_url
}
) for item in df.itertuples()
]

#創建一個用于編制文檔索引的管道
indexing_pipeline = Pipeline()

#使用句子轉換器模型向管道中添加一個文檔嵌入器
indexing_pipeline.add_component(
instance=SentenceTransformersDocumentEmbedder(model="sentence-transformers/all-MiniLM-L6-v2"), name="doc_embedder"
)

# 向管道中添加文檔寫入器，以便在文檔存儲區中存儲文檔
indexing_pipeline.add_component(instance=DocumentWriter(document_store=document_store), name="doc_writer")

#將嵌入器的輸出連接到寫入器的輸入
indexing_pipeline.connect("doc_embedder.documents", "doc_writer.documents")

#運行索引管道來處理和存儲文檔
indexing_pipeline.run({"doc_embedder": {"documents": documents}})

太好了，我們已經完成了AI代理應用程序的第一步。現在，是時候構建產品標識符函數工具了。為了更好地理解產品標識符的主要任務，讓我們考慮下面的示例。

用戶查詢內容如下：

英語原文： I want to buy a camping boot, a charcoal and google pixel 9 back cover.

中文意思：我想買一雙露營靴、一塊木炭和谷歌pixel 9手機外殼。

現在，先讓我們了解一下產品標識符函數的理想化工作流程。

產品標識函數工作流程

首先，我們需要創建一個工具來分析用戶查詢并識別用戶感興趣的產品。我們可以使用下面的代碼片段構建這樣一個工具。

構建用戶查詢分析器

template = """
Understand the user query and list of products the user is interested in and return product names as list.
You should always return a Python list. Do not return any explanation.

Examples:
Question: I am interested in camping boots, charcoal and disposable rain jacket.
Answer: ["camping_boots","charcoal","disposable_rain_jacket"]

Question: Need a laptop, wireless mouse, and noise-cancelling headphones for work.
Answer: ["laptop","wireless_mouse","noise_cancelling_headphones"]

Question: {{ question }}
Answer:
"""

product_identifier = Pipeline()

product_identifier.add_component("prompt_builder", PromptBuilder(template=template))
product_identifier.add_component("llm", generator())

product_identifier.connect("prompt_builder", "llm")

好了，現在我們已經完成了第一個函數的一半，現在是時候通過添加RAG管道來完成該函數了。

產品標識功能工作流程

創建RAG管道

template = """
Return product name, price, and url as a python dictionary. 
You should always return a Python dictionary with keys price, name and url for single product.
You should always return a Python list of dictionaries with keys price, name and url for multiple products.
Do not return any explanation.

Legitimate Response Schema:
{"price": "float", "name": "string", "url": "string"}
Legitimate Response Schema for multiple products:
[{"price": "float", "name": "string", "url": "string"},{"price": "float", "name": "string", "url": "string"}]

Context:
{% for document in documents %}
product_price: {{ document.meta['price'] }}
product_url: {{ document.meta['url'] }}
product_id: {{ document.meta['id'] }}
product_name: {{ document.content }}
{% endfor %}
Question: {{ question }}
Answer:
"""

rag_pipe = Pipeline()
rag_pipe.add_component("embedder", SentenceTransformersTextEmbedder(model="sentence-transformers/all-MiniLM-L6-v2"))
rag_pipe.add_component("retriever", InMemoryEmbeddingRetriever(document_store=document_store, top_k=5))
rag_pipe.add_component("prompt_builder", PromptBuilder(template=template))
rag_pipe.add_component("llm", generator())

rag_pipe.connect("embedder.embedding", "retriever.query_embedding")
rag_pipe.connect("retriever", "prompt_builder.documents")
rag_pipe.connect("prompt_builder", "llm")

執行上面的代碼之后，我們就完成了RAG和查詢分析管道的構建。現在是時候把它轉換成一個工具了。為此，我們可以使用常規函數聲明，如下所示。為AI代理創建工具就像創建Python函數一樣。如果你有類似于下面這樣的問題：

代理如何調用這個函數？

解決方案很簡單：利用特定于模型的工具模式。當然，我們將在稍后的步驟中加入該模式。現在，是時候創建一個同時使用查詢分析器和RAG管道的包裝器函數了。

還是先讓我們來明確一下這個函數的目標。

目標1：識別用戶感興趣的所有產品，并將其作為列表返回。

目標2：對于每個已識別的產品，從數據庫中檢索最多五個產品及其元數據。

實現產品標識符函數

def product_identifier_func(query: str):
"""
根據給定的查詢來標識產品，并檢索每個已標識的產品的相關詳細信息。

參數:
query (str): 用于標識產品的查詢字符串。

返回值:
dict: 一個字典，其中鍵是產品名稱，值是每個產品的詳細信息。如果沒有找到產品，則返回“No product found”。
"""
product_understanding = product_identifier.run({"prompt_builder": {"question": query}})

try:
product_list = literal_eval(product_understanding["llm"]["replies"][0])
except:
return "No product found"

results = {}

for product in product_list:
response = rag_pipe.run({"embedder": {"text": product}, "prompt_builder": {"question": product}})
try:
results[product] = literal_eval(response["llm"]["replies"][0])
except:
results[product] = {}

return results

產品標識函數工作流程

至此，我們完成了代理的第一個工具的構建。現在，先讓我們來看看它是否按預期工作。

query = "I want crossbow and woodstock puzzle"
#執行函數
product_identifier_func(query)

# {'crossbow': {'name': 'DB Longboards CoreFlex Crossbow 41" Bamboo Fiberglass '
#                        'Longboard Complete',
#                'price': 237.68,
#                'url': 'https://www.amazon.com/DB-Longboards-CoreFlex-Fiberglass-Longboard/dp/B07KMVJJK7'},
#  'woodstock_puzzle': {'name': 'Woodstock- Collage 500 pc Puzzle',
#                       'price': 17.49,
#                       'url': 'https://www.amazon.com/Woodstock-Collage-500-pc-Puzzle/dp/B07MX21WWX'}}

成功了！然而，值得注意的是這里返回的輸出模式。下面給出輸出的總體模式架構。

{
"product_key": {
"name": "string",
"price": "float",
"url": "string"
}
}

這正是我們建議RAG管道中生成的模式。下一步，讓我們構建一個名為find_budget_friend_option的可選工具函數。

def find_budget_friendly_option(selected_product_details):
"""
為每一類產品找到最經濟友好的選擇。

參數:
selected_product_details (dict): 一個字典，其中的鍵是產品類別和值是列表的產品細節。每個產品的細節都應該是一個包含一個“price”鍵的字典。

返回結果:
dict: 一個字典，其中鍵是產品類別，值是每個類別的最經濟友好的產品詳細信息。
"""
budget_friendly_options = {}

for category, items in selected_product_details.items():
if isinstance(items, list):
lowest_price_item = min(items, key=lambda x: x['price'])
else:
lowest_price_item = items

budget_friendly_options[category] = lowest_price_item

return budget_friendly_options

讓我們關注這個應用程序最關鍵的方面，也就是，讓AI代理能夠根據需要使用這些功能。正如我們之前所討論的，這可以通過特定于模型的工具模式來實現。因此，我們需要定位特定于所選模型的工具模式。幸運的是，Groq模型庫（https://huggingface.co/Groq/Llama-3-Groq-70B-Tool-Use）中提到了這一點。我們僅需要把它調整一下，以適應我們的使用場景即可。

最終確定聊天模板

chat_template = '''<|start_header_id|>system<|end_header_id|>

You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
<tool_call>
{"name": <function-name>,"arguments": <args-dict>}
</tool_call>

Here are the available tools:
<tools>
{
"name": "product_identifier_func",
"description": "To understand user interested products and its details",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "The query to use in the search. Infer this from the user's message. It should be a question or a statement"
}
},
"required": ["query"]
}
},
{
"name": "find_budget_friendly_option",
"description": "Get the most cost-friendly option. If selected_product_details has morethan one key this should return most cost-friendly options",
"parameters": {
"type": "object",
"properties": {
"selected_product_details": {
"type": "dict",
"description": "Input data is a dictionary where each key is a category name, and its value is either a single dictionary with 'price', 'name', and 'url' keys or a list of such dictionaries; example: {'category1': [{'price': 10.5, 'name': 'item1', 'url': 'http://example.com/item1'}, {'price': 8.99, 'name': 'item2', 'url': 'http://example.com/item2'}], 'category2': {'price': 15.0, 'name': 'item3', 'url': 'http://example.com/item3'}}"
}
},
"required": ["selected_product_details"]
}
}
</tools><|eot_id|><|start_header_id|>user<|end_header_id|>

I need to buy a crossbow<|eot_id|><|start_header_id|>assistant<|end_header_id|>

<tool_call>
{"id":"call_deok","name":"product_identifier_func","arguments":{"query":"I need to buy a crossbow"}}
</tool_call><|eot_id|><|start_header_id|>tool<|end_header_id|>

<tool_response>
{"id":"call_deok","result":{'crossbow': {'price': 237.68,'name': 'crossbow','url': 'https://www.amazon.com/crossbow/dp/B07KMVJJK7'}}}
</tool_response><|eot_id|><|start_header_id|>assistant<|end_header_id|>
'''

現在，只剩下幾步了。在做任何事情之前，還是先讓我們來測試一下我們的代理。

##測試代理
messages = [
ChatMessage.from_system(
chat_template
),
ChatMessage.from_user("I need to buy a crossbow for my child and Pokémon for myself."),
]

chat_generator = get_chat_generator()
response = chat_generator.run(messages=messages)
pprint(response)

## 響應結果
{'replies': [ChatMessage(content='<tool_call>\n'
'{"id": 0, "name": "product_identifier_func", '
'"arguments": {"query": "I need to buy a '
'crossbow for my child"}}\n'
'</tool_call>\n'
'<tool_call>\n'
'{"id": 1, "name": "product_identifier_func", '
'"arguments": {"query": "I need to buy a '
'Pokemon for myself"}}\n'
'</tool_call>',
role=<ChatRole.ASSISTANT: 'assistant'>,
name=None,
meta={'finish_reason': 'stop',
'index': 0,
'model': 'llama3-groq-70b-8192-tool-use-preview',
'usage': {'completion_time': 0.217823967,
'completion_tokens': 70,
'prompt_time': 0.041348261,
'prompt_tokens': 561,
'total_time': 0.259172228,
'total_tokens': 631}})]}

至此，我們已經完成了大約90%的工作。

工作接近尾聲。

在上述響應結果中，你可能已經注意到XML標簽<tool_call>包含了工具調用。因此，我們需要開發一種機制來提取tool_call對象。

def extract_tool_calls(tool_calls_str):
json_objects = re.findall(r'<tool_call>(.*?)</tool_call>', tool_calls_str, re.DOTALL)

result_list = [json.loads(obj) for obj in json_objects]

return result_list

available_functions = {
"product_identifier_func": product_identifier_func, 
"find_budget_friendly_option": find_budget_friendly_option
}

完成此步驟后，當代理調用工具時，我們可以直接訪問代理的響應。現在唯一懸而未決的是獲取工具調用對象并相應地執行函數。讓我們也把這一部分完成。

messages.append(ChatMessage.from_user(message))
response = chat_generator.run(messages=messages)

if response and "<tool_call>" in response["replies"][0].content:
function_calls = extract_tool_calls(response["replies"][0].content)
for function_call in function_calls:
# 解析函數調用信息
function_name = function_call["name"]
function_args = function_call["arguments"]

#找到相應的函數并用給定的參數調用它
function_to_call = available_functions[function_name]
function_response = function_to_call(**function_args)

# 使用`ChatMessage.from_function`在消息列表中附加函數響應
messages.append(ChatMessage.from_function(content=json.dumps(function_response), name=function_name))
response = chat_generator.run(messages=messages)

現在，是時候將前面的每個組件連接在一起，從而構建一個完整的聊天應用程序了。為此，我選擇使用強大的開源的深度學習模型可視化工具Gradio。

import gradio as gr

messages = [ChatMessage.from_system(chat_template)]
chat_generator = get_chat_generator()

def chatbot_with_fc(message, messages):
messages.append(ChatMessage.from_user(message))
response = chat_generator.run(messages=messages)

while True:
if response and "<tool_call>" in response["replies"][0].content:
function_calls = extract_tool_calls(response["replies"][0].content)
for function_call in function_calls:
#解析函數調用信息
function_name = function_call["name"]
function_args = function_call["arguments"]

#找到相應的函數并用給定的參數調用它
function_to_call = available_functions[function_name]
function_response = function_to_call(**function_args)

# 使用`ChatMessage.from_function`在消息列表中附加函數響應
messages.append(ChatMessage.from_function(content=json.dumps(function_response), name=function_name))
response = chat_generator.run(messages=messages)

# 定期對話
else:
messages.append(response["replies"][0])
break
return response["replies"][0].content


def chatbot_interface(user_input, state):
response_content = chatbot_with_fc(user_input, state)
return response_content, state

with gr.Blocks() as demo:
gr.Markdown("# AI Purchase Assistant")
gr.Markdown("Ask me about products you want to buy!")

state = gr.State(value=messages)

with gr.Row():
user_input = gr.Textbox(label="Your message:")
response_output = gr.Markdown(label="Response:")

user_input.submit(chatbot_interface, [user_input, state], [response_output, state])
gr.Button("Send").click(chatbot_interface, [user_input, state], [response_output, state])


demo.launch()

就是這么簡單！至此，我們已經成功構建了一個基于Llama 3模型的人工智能代理程序，它本身具有函數調用功能。你可以從GitHub倉庫（https://github.com/Ransaka/ai-agents-with-llama3）訪問其完整的源代碼。

此外，你可以通過Kaggle鏈接（https://www.kaggle.com/datasets/promptcloud/amazon-product-dataset-2020）訪問本文中使用的數據集。

結論

歸納來看，在構建基于人工智能代理的系統程序時，重要的是要考慮完成任務所需的時間以及每個任務所使用的API調用（令牌）的數量。這方面開發面臨的一個主要挑戰是減少系統中的幻覺，這也是當前一個十分活躍的研究領域。因此，構建LLM和代理系統沒有固定的規則。開發團隊有必要耐心和戰略性地規劃工作，以確保人工智能代理LLM正常運行。

最后，除非另有說明，本文中所有圖片均由作者本人提供。

參考資料

《Llama 3.1簡介：我們的迄今為止最強大的模型》，我們的最新模型為所有人帶來了開放式智能，擴展了上下文長度，增加了對八種語言的支持，等等。鏈接地址：https://ai.meta.com/blog/meta-llama-3-1/?source=post_page-----7e74f79d1ccc--------------------------------
《Groq/Llama-3-Groq-70B-Tool-Use · Hugging Face》，我們正在通過開源和開放科學推進人工智能并使其民主化。鏈接地址：https://huggingface.co/Groq/Llama-3-Groq-70B-Tool-Use?source=post_page-----7e74f79d1ccc--------------------------------
https://docs.together.ai/docs/llama-3-function-calling

譯者介紹

朱先忠，51CTO社區編輯，51CTO專家博客、講師，濰坊一所高校計算機教師，自由編程界老兵一枚。

原文標題：Using Llama 3 for Building AI Agents，作者：Ransaka Ravihara

責任編輯：姜華來源： 51CTO內容精選