func main() {
	text := `
您应该提供尽可能清晰、具体的指示，以表达您希望模型执行的任务。\
这将引导模型朝向所需的输出，并降低收到无关或不正确响应的可能性。\
不要将写清晰的提示词与写简短的提示词混淆。\
在许多情况下，更长的提示词可以为模型提供更多的清晰度和上下文信息，从而导致更详细和相关的输出。
    `
	prompt := `
	把用两个双引号括起来的文本总结成一句话。
	"%s"
	`
	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	prompt := `
	请生成包括书名、作者和类别的三本虚构的、非真实存在的中文书籍清单，\
并以JSON格式提供，其中包含以下键:book_id、title、author、genre。
	`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), prompt)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

// 制作茶的步骤
func main() {
	text1 := `
	泡一杯茶很容易。首先，需要把水烧开。\
在等待期间，拿一个杯子并把茶包放进去。\
一旦水足够热，就把它倒在茶包上。\
等待一会儿，让茶叶浸泡。几分钟后，取出茶包。\
如果您愿意，可以加一些糖或牛奶调味。\
就这样，您可以享受一杯美味的茶了。
`
	prompt := `
您将获得由两个双引号括起来的文本。\
如果它包含一系列的指令，则需要按照以下格式重新编写这些指令：

第一步 - ...
第二步 - …
…
第N步 - …

如果文本中不包含一系列的指令，则直接写“未提供步骤”。
"%s"
	`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text1))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

// 一段没有明确步骤的文本
func main() {
	text2 := `
	泡一杯茶很容易。首先，需要把水烧开。\
在等待期间，拿一个杯子并把茶包放进去。\
一旦水足够热，就把它倒在茶包上。\
等待一会儿，让茶叶浸泡。几分钟后，取出茶包。\
如果您愿意，可以加一些糖或牛奶调味。\
就这样，您可以享受一杯美味的茶了。
`
	prompt := `
您将获得由两个双引号括起来的文本。\
如果它包含一系列的指令，则需要按照以下格式重新编写这些指令：

第一步 - ...
第二步 - …
…
第N步 - …

如果文本中不包含一系列的指令，则直接写“未提供步骤”。
"%s"
	`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text2))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	prompt := `
您的任务是以一致的风格回答问题。

<孩子>: 请教我何为耐心。

<祖父母>: 挖出最深峡谷的河流源于一处不起眼的泉眼；最宏伟的交响乐从单一的音符开始；最复杂的挂毯以一根孤独的线开始编织。

<孩子>: 请教我何为韧性。
	`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), prompt)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	text := `
在一个迷人的村庄里，兄妹杰克和吉尔出发去一个山顶井里打水。\
他们一边唱着欢乐的歌，一边往上爬，\
然而不幸降临——杰克绊了一块石头，从山上滚了下来，吉尔紧随其后。\
虽然略有些摔伤，但他们还是回到了温馨的家中。\
尽管出了这样的意外，他们的冒险精神依然没有减弱，继续充满愉悦地探索。
`
	prompt := `
执行以下操作：
1-用一句话概括下面用两个双反引号括起来的文本。
2-将摘要翻译成英语。
3-在英语摘要中列出每个人名。
4-输出一个 JSON 对象，其中包含以下键：english_summary，num_names。

请用换行符分隔您的答案。

"%s"
	`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	text := `
在一个迷人的村庄里，兄妹杰克和吉尔出发去一个山顶井里打水。\
他们一边唱着欢乐的歌，一边往上爬，\
然而不幸降临——杰克绊了一块石头，从山上滚了下来，吉尔紧随其后。\
虽然略有些摔伤，但他们还是回到了温馨的家中。\
尽管出了这样的意外，他们的冒险精神依然没有减弱，继续充满愉悦地探索。
`
	prompt := `
1-用一句话概括下面用双引号括起来的文本。
2-将摘要翻译成英语。
3-在英语摘要中列出每个名称。
4-输出一个 JSON 对象，其中包含以下键：English_summary，num_names。

请使用以下格式：
文本：<要总结的文本>
摘要：<摘要>
翻译：<摘要的翻译>
名称：<英语摘要中的名称列表>
输出 JSON：<带有 English_summary 和 num_names 的 JSON>

"%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	prompt := `
判断学生的解决方案是否正确。

问题:
我正在建造一个太阳能发电站，需要帮助计算财务。

    土地费用为 100美元/平方英尺
    我可以以 250美元/平方英尺的价格购买太阳能电池板
    我已经谈判好了维护合同，每年需要支付固定的10万美元，并额外支付每平方英尺10美元
    作为平方英尺数的函数，首年运营的总费用是多少。

学生的解决方案：
设x为发电站的大小，单位为平方英尺。
费用：

    土地费用：100x
    太阳能电池板费用：250x
    维护费用：100,000美元+100x
    总费用：100x+250x+100,000美元+100x=450x+100,000美元
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), prompt)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	prompt := `
请判断学生的解决方案是否正确，请通过如下步骤解决这个问题：

步骤：

    首先，自己解决问题。
    然后将您的解决方案与学生的解决方案进行比较，对比计算得到的总费用与学生计算的总费用是否一致，并评估学生的解决方案是否正确。
    在自己完成问题之前，请勿决定学生的解决方案是否正确。

使用以下格式：

    问题：问题文本
    学生的解决方案：学生的解决方案文本
    实际解决方案和步骤：实际解决方案和步骤文本
    学生计算的总费用：学生计算得到的总费用
    实际计算的总费用：实际计算出的总费用
    学生计算的费用和实际计算的费用是否相同：是或否
    学生的解决方案和实际解决方案是否相同：是或否
    学生的成绩：正确或不正确

问题：

    我正在建造一个太阳能发电站，需要帮助计算财务。 
    - 土地费用为每平方英尺100美元
    - 我可以以每平方英尺250美元的价格购买太阳能电池板
    - 我已经谈判好了维护合同，每年需要支付固定的10万美元，并额外支付每平方英尺10美元;

    作为平方英尺数的函数，首年运营的总费用是多少。

学生的解决方案：

    设x为发电站的大小，单位为平方英尺。
    费用：
    1. 土地费用：100x美元
    2. 太阳能电池板费用：250x美元
    3. 维护费用：100,000+100x=10万美元+10x美元
    总费用：100x美元+250x美元+10万美元+100x美元=450x+10万美元

实际解决方案和步骤：
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), prompt)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	prompt := `
告诉我华为公司生产的GT Watch运动手表的相关信息
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), prompt)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	text := `
	You should express what you want a model to do by \ 
providing instructions that are as clear and \ 
specific as you can possibly make them. \ 
This will guide the model towards the desired output, \ 
and reduce the chances of receiving irrelevant \ 
or incorrect responses. Don't confuse writing a \ 
clear prompt with writing a short prompt. \ 
In many cases, longer prompts provide more clarity \ 
and context for the model, which can lead to \ 
more detailed and relevant outputs.
`
	prompt := `
Summarize the text delimited by two double quotes \ 
into a single sentence.
"%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	prompt := `
Generate a list of three made-up book titles along \ 
with their authors and genres. 
Provide them in JSON format with the following keys: 
book_id, title, author, genre.
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), prompt)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	text1 := `
	Making a cup of tea is easy! First, you need to get some \
	water boiling. While that's happening, \ 
	grab a cup and put a tea bag in it. Once the water is \
	hot enough, just pour it over the tea bag. \
	Let it sit for a bit so the tea can steep. After a \
	few minutes, take out the tea bag. If you \
	like, you can add some sugar or milk to taste. \
	And that's it! You've got yourself a delicious \
	cup of tea to enjoy.
	`
	prompt := `
You will be provided with text delimited by two double quotes. 
If it contains a sequence of instructions, \ 
re-write those instructions in the following format:

Step 1 - ...
Step 2 - …
…
Step N - …

If the text does not contain a sequence of instructions, \ 
then simply write \"No steps provided.

"%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text1))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	text2 := `
The sun is shining brightly today, and the birds are \
singing. It's a beautiful day to go for a \ 
walk in the park. The flowers are blooming, and the \ 
trees are swaying gently in the breeze. People \ 
are out and about, enjoying the lovely weather. \ 
Some are having picnics, while others are playing \ 
games or simply relaxing on the grass. It's a \ 
perfect day to spend time outdoors and appreciate the \ 
beauty of nature.
	`
	prompt := `
You will be provided with text delimited by two double quotes. 
If it contains a sequence of instructions, \ 
re-write those instructions in the following format:

Step 1 - ...
Step 2 - …
…
Step N - …

If the text does not contain a sequence of instructions, \ 
then simply write \"No steps provided.

"%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text2))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	prompt := `
Your task is to answer in a consistent style.

<child>: Teach me about patience.

<grandparent>: The river that carves the deepest \ 
valley flows from a modest spring; the \ 
grandest symphony originates from a single note; \ 
the most intricate tapestry begins with a solitary thread.

<child>: Teach me about resilience.
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), prompt)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	text := `
In a charming village, siblings Jack and Jill set out on \ 
a quest to fetch water from a hilltop \ 
well. As they climbed, singing joyfully, misfortune \ 
struck—Jack tripped on a stone and tumbled \ 
down the hill, with Jill following suit. \ 
Though slightly battered, the pair returned home to \ 
comforting embraces. Despite the mishap, \ 
their adventurous spirits remained undimmed, and they \ 
continued exploring with delight.
	`
	prompt1 := `
Perform the following actions: 
1 - Summarize the following text delimited by two double \
backticks with 1 sentence.
2 - Translate the summary into French.
3 - List each name in the French summary.
4 - Output a json object that contains the following \
keys: french_summary, num_names.

Separate your answers with line breaks.

Text:
"%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt1, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println("Completion for prompt 1: \n", resp.Choices[0].Message.Content)
}

func main() {
	text := `
In a charming village, siblings Jack and Jill set out on \ 
a quest to fetch water from a hilltop \ 
well. As they climbed, singing joyfully, misfortune \ 
struck—Jack tripped on a stone and tumbled \ 
down the hill, with Jill following suit. \ 
Though slightly battered, the pair returned home to \ 
comforting embraces. Despite the mishap, \ 
their adventurous spirits remained undimmed, and they \ 
continued exploring with delight.
	`
	prompt2 := `
Your task is to perform the following actions: 
1 - Summarize the following text delimited by <> with 1 sentence.
2 - Translate the summary into French.
3 - List each name in the French summary.
4 - Output a json object that contains the 
following keys: french_summary, num_names.

Use the following format:
Text: <text to summarize>
Summary: <summary>
Translation: <summary translation>
Names: <list of names in French summary>
Output JSON: <json with summary and num_names>

Text: <%s>
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt2, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println("Completion for prompt 2: \n", resp.Choices[0].Message.Content)
}

func main() {
	prompt := `
Determine if the student's solution is correct or not.

Question:
I'm building a solar power installation and I need \
 help working out the financials. 
- Land costs $100 / square foot
- I can buy solar panels for $250 / square foot
- I negotiated a contract for maintenance that will cost \ 
me a flat $100k per year, and an additional $10 / square \
foot
What is the total cost for the first year of operations 
as a function of the number of square feet.

Student's Solution:
Let x be the size of the installation in square feet.
Costs:
1. Land cost: 100x
2. Solar panel cost: 250x
3. Maintenance cost: 100,000 + 100x
Total cost: 100x + 250x + 100,000 + 100x = 450x + 100,000
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), prompt)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	prompt := `
Your task is to determine if the student's solution \
is correct or not.
To solve the problem do the following:
- First, work out your own solution to the problem. 
- Then compare your solution to the student's solution \ 
and evaluate if the student's solution is correct or not. 
Don't decide if the student's solution is correct until 
you have done the problem yourself.

Use the following format:
Question:
I'm building a solar power installation and I need \
 help working out the financials. 
- Land costs $100 / square foot
- I can buy solar panels for $250 / square foot
- I negotiated a contract for maintenance that will cost \ 
me a flat $100k per year, and an additional $10 / square \
foot
What is the total cost for the first year of operations 
as a function of the number of square feet.

Student's Solution:
Let x be the size of the installation in square feet.
Costs:
1. Land cost: 100x
2. Solar panel cost: 250x
3. Maintenance cost: 100,000 + 100x
Total cost: 100x + 250x + 100,000 + 100x = 450x + 100,000

Actual solution:

Is the student's solution the same as actual solution \
just calculated:

Student grade:
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), prompt)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	prompt := `
Tell me about AeroGlide UltraSlim Smart Toothbrush by Boie
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), prompt)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	text := `
概述

    美丽的中世纪风格办公家具系列的一部分，包括文件柜、办公桌、书柜、会议桌等。
    多种外壳颜色和底座涂层可选。
    可选塑料前后靠背装饰（SWC-100）或10种面料和6种皮革的全面装饰（SWC-110）。
    底座涂层选项为：不锈钢、哑光黑色、光泽白色或铬。
    椅子可带或不带扶手。
    适用于家庭或商业场所。
    符合合同使用资格。

结构

    五个轮子的塑料涂层铝底座。
    气动椅子调节，方便升降。

尺寸

    宽度53厘米|20.87英寸
    深度51厘米|20.08英寸
    高度80厘米|31.50英寸
    座椅高度44厘米|17.32英寸
    座椅深度41厘米|16.14英寸

选项

    软地板或硬地板滚轮选项。
    两种座椅泡沫密度可选：中等（1.8磅/立方英尺）或高（2.8磅/立方英尺）。
    无扶手或8个位置PU扶手。

材料
外壳底座滑动件

    改性尼龙PA6/PA66涂层的铸铝。
    外壳厚度：10毫米。
    座椅
    HD36泡沫

原产国

    意大利
`

	prompt := `
您的任务是帮助营销团队基于技术说明书创建一个产品的营销描述。

根据两个双引号标记的技术说明书中提供的信息，编写一个产品描述。

技术说明: "%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	text := `
概述

    美丽的中世纪风格办公家具系列的一部分，包括文件柜、办公桌、书柜、会议桌等。
    多种外壳颜色和底座涂层可选。
    可选塑料前后靠背装饰（SWC-100）或10种面料和6种皮革的全面装饰（SWC-110）。
    底座涂层选项为：不锈钢、哑光黑色、光泽白色或铬。
    椅子可带或不带扶手。
    适用于家庭或商业场所。
    符合合同使用资格。

结构

    五个轮子的塑料涂层铝底座。
    气动椅子调节，方便升降。

尺寸

    宽度53厘米|20.87英寸
    深度51厘米|20.08英寸
    高度80厘米|31.50英寸
    座椅高度44厘米|17.32英寸
    座椅深度41厘米|16.14英寸

选项

    软地板或硬地板滚轮选项。
    两种座椅泡沫密度可选：中等（1.8磅/立方英尺）或高（2.8磅/立方英尺）。
    无扶手或8个位置PU扶手。

材料
外壳底座滑动件

    改性尼龙PA6/PA66涂层的铸铝。
    外壳厚度：10毫米。
    座椅
    HD36泡沫

原产国

    意大利
`

	prompt := `
您的任务是帮助营销团队基于技术说明书创建一个产品的营销描述。

根据两个双引号标记的技术说明书中提供的信息，编写一个产品描述。

使用最多50个词。

技术说明: "%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	res := resp.Choices[0].Message.Content
	fmt.Println(res)
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Product Description</title>
</head>
<body>
    <div>
        <h2>产品描述</h2>
        <p>我们隆重推出美丽的中世纪风格办公家具系列，包括文件柜、办公桌、书柜、会议桌等。您可以根据饰。底座涂层选项为不锈钢、哑光黑色、光泽白色或铬，而椅子可选择带扶手或不带扶手。这些家具适用于家庭或商业场所，并且符合合同使用资格。</p>
        <p>产品的结构特点包括五个轮子的塑料涂层铝底座和气动椅子调节功能，方便升降。</p>
        <h3>材料构造</h3>
        <p>外壳底座滑动件由改性尼龙PA6/PA66涂层的铸铝制成，外壳厚度为10毫米。而座椅使用了HD36泡沫材料。</p>
        <p>产品ID: 5623874</p>
    </div>

    <h2>产品尺寸</h2>
    <table>
        <tr>
            <td>宽度</td>
            <td>20.87英寸</td>
        </tr>
        <tr>
            <td>深度</td>
            <td>20.08英寸</td>
        </tr>
        <tr>
            <td>高度</td>
            <td>31.50英寸</td>
        </tr>
        <tr>
            <td>座椅高度</td>
            <td>17.32英寸</td>
        </tr>
        <tr>
            <td>座椅深度</td>
            <td>16.14英寸</td>
        </tr>
    </table>
</body>
</html>

prompt := `
Your task is to help a marketing team create a 
description for a retail website of a product based 
on a technical fact sheet.

Write a product description based on the information 
provided in the technical specifications delimited by 
two double quotes.

Technical specifications: "%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	res := resp.Choices[0].Message.Content
	fmt.Println(res)

prompt := `
Your task is to help a marketing team create a 
description for a retail website of a product based 
on a technical fact sheet.

Write a product description based on the information 
provided in the technical specifications delimited by 
two double quotes.

Use at most 50 words.

Technical specifications: "%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	res := resp.Choices[0].Message.Content
	fmt.Println(res)

	prompt := `
Your task is to help a marketing team create a 
description for a retail website of a product based 
on a technical fact sheet.

Write a product description based on the information 
provided in the technical specifications delimited by 
two double quotes.

The description is intended for furniture retailers, 
so should be technical in nature and focus on the 
materials the product is constructed from.

Use at most 50 words.

Technical specifications: "%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	res := resp.Choices[0].Message.Content
	fmt.Println(res)

	prompt := `
Your task is to help a marketing team create a 
description for a retail website of a product based 
on a technical fact sheet.

Write a product description based on the information 
provided in the technical specifications delimited by 
two double quotes.

The description is intended for furniture retailers, 
so should be technical in nature and focus on the 
materials the product is constructed from.

At the end of the description, include every 7-character 
Product ID in the technical specification.

Use at most 50 words.

Technical specifications: "%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	res := resp.Choices[0].Message.Content
	fmt.Println(res)

	prompt := `
Your task is to help a marketing team create a 
description for a retail website of a product based 
on a technical fact sheet.

Write a product description based on the information 
provided in the technical specifications delimited by 
two double quotes.

The description is intended for furniture retailers, 
so should be technical in nature and focus on the 
materials the product is constructed from.

At the end of the description, include every 7-character 
Product ID in the technical specification.

After the description, include a table that gives the 
product's dimensions. The table should have two columns.
In the first column include the name of the dimension. 
In the second column include the measurements in inches only.

Give the table the title 'Product Dimensions'.

Format everything as HTML that can be used in a website. 
Place the description in a <div> element.

Technical specifications: "%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	res := resp.Choices[0].Message.Content
	fmt.Println(res)

<div>
  <p>This mid-century inspired office chair is the perfect addition to any home or business setting. The chair is available with various options for shell color, base finishes, and upholstery, making it easy to find the perfect match for any decor. The 5-wheel plastic coated aluminum base provides stability and maneuverability, while the pneumatic chair adjustment allows for easy raise/lower action. The seat is constructed with HD36 foam for ultimate comfort, and the shell base glider is made of cast aluminum with a modified nylon PA6/PA66 coating. With its stylish design and high-quality construction, this chair is ideal for any office space or meeting room.</p>
  <p>Product ID: SWC-100, SWC-110</p>
  <table>
    <caption>Product Dimensions</caption>
    <tr>
      <th>WIDTH</th>
      <td>20.87 inches</td>
    </tr>
    <tr>
      <th>DEPTH</th>
      <td>20.08 inches</td>
    </tr>
    <tr>
      <th>HEIGHT</th>
      <td>31.50 inches</td>
    </tr>
    <tr>
      <th>SEAT HEIGHT</th>
      <td>17.32 inches</td>
    </tr>
    <tr>
      <th>SEAT DEPTH</th>
      <td>16.14 inches</td>
    </tr>
  </table>
</div>

func main() {
	text := `
这个熊猫公仔是我给女儿的生日礼物，她很喜欢，去哪都带着。
公仔很软，超级可爱，面部表情也很和善。但是相比于价钱来说，
它有点小，我感觉在别的地方用同样的价钱能买到更大的。
快递比预期提前了一天到货，所以在送给女儿之前，我自己玩了会。
`
	prompt := `
您的任务是从电子商务网站上生成一个产品评论的简短摘要。

请对两个双引号之间的评论文本进行概括，最多30个字。

评论: "%s"
`

	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	res := resp.Choices[0].Message.Content
	fmt.Println(res)
}

可爱软萌的熊猫公仔，面部表情和善，快递提前一天到货，值得购买。

func main() {
	text1 := `
这个熊猫公仔是我给女儿的生日礼物，她很喜欢，去哪都带着。
公仔很软，超级可爱，面部表情也很和善。但是相比于价钱来说，
它有点小，我感觉在别的地方用同样的价钱能买到更大的。
快递比预期提前了一天到货，所以在送给女儿之前，我自己玩了会。
`

	// 评论一盏落地灯
	text2 := `
我需要一盏漂亮的卧室灯，这款灯不仅具备额外的储物功能，价格也并不算太高。
收货速度非常快，仅用了两天的时间就送到了。
不过，在运输过程中，灯的拉线出了问题，幸好，公司很乐意寄送了一根全新的灯线。
新的灯线也很快就送到手了，只用了几天的时间。
装配非常容易。然而，之后我发现有一个零件丢失了，于是我联系了客服，他们迅速地给我寄来了缺失的零件！
对我来说，这是一家非常关心客户和产品的优秀公司。
`

	// 评论一把电动牙刷
	text3 := `
我的牙科卫生员推荐了电动牙刷，所以我就买了这款。
到目前为止，电池续航表现相当不错。
初次充电后，我在第一周一直将充电器插着，为的是对电池进行条件养护。
过去的3周里，我每天早晚都使用它刷牙，但电池依然维持着原来的充电状态。
不过，牙刷头太小了。我见过比这个牙刷头还大的婴儿牙刷。
我希望牙刷头更大一些，带有不同长度的刷毛，
这样可以更好地清洁牙齿间的空隙，但这款牙刷做不到。
总的来说，如果你能以50美元左右的价格购买到这款牙刷，那是一个不错的交易。
制造商的替换刷头相当昂贵，但你可以购买价格更为合理的通用刷头。
这款牙刷让我感觉就像每天都去了一次牙医，我的牙齿感觉非常干净！
`

	// 评论一台搅拌机
	text4 := `
在11月份期间，这个17件套装还在季节性促销中，售价约为49美元，打了五折左右。可是由于某种原因（我们可以称之为价格上涨），到了12月的第二周，所有的价格都上涨了，
同样的套装价格涨到了70-89美元不等。而11件套装的价格也从之前的29美元上涨了约10美元。看起来还算不错，但是如果你仔细看底座，刀片锁定的部分看起来没有前几年版本的那么漂亮。
然而，我打算非常小心地使用它（例如，我会先在搅拌机中研磨豆类、冰块、大米等坚硬的食物，然后再将它们研磨成所需的粒度，接着切换到打蛋器刀片以获得更细的面粉，如果我需要制作更细腻/少果肉的食物）。
在制作冰沙时，我会将要使用的水果和蔬菜切成细小块并冷冻（如果使用菠菜，我会先轻微煮熟菠菜，然后冷冻，直到使用时准备食用。
如果要制作冰糕，我会使用一个小到中号的食物加工器），这样你就可以避免添加过多的冰块。大约一年后，电机开始发出奇怪的声音。我打电话给客户服务，但保修期已经过期了，
所以我只好购买了另一台。值得注意的是，这类产品的整体质量在过去几年里有所下降，所以他们在一定程度上依靠品牌认知和消费者忠诚来维持销售。在大约两天内，我收到了新的搅拌机。
`

	prompt := `
您的任务是从电子商务网站上的产品评论中提取相关信息。

请对两个双引号之间的评论文本进行概括，最多20个词汇。

评论: "%s"
`

	for i, text := range []string{text1, text2, text3, text4} {
		client := newOpenAIClient()
		resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, text))
		if err != nil {
			fmt.Printf("ChatCompletion error: %v\n", err)
			return
		}
		res := resp.Choices[0].Message.Content
		fmt.Printf("评论%d: %s\n", i+1, res)
	}
}

{
    "物品": "卧室灯",
    "品牌": "Lumina"
}

func (c *openAIClient) CreateChatCompletionWithMessage(ctx context.Context, messages []openai.ChatCompletionMessage) (openai.ChatCompletionResponse, error) {
	return c.Client.CreateChatCompletion(ctx, openai.ChatCompletionRequest{
		Model:       openai.GPT3Dot5Turbo,
		Messages:    messages,
		Temperature: 1,
	})
}

func main() {
	client := newOpenAIClient()
	messages := []openai.ChatCompletionMessage{
		{
			Role:    openai.ChatMessageRoleSystem,
			Content: "你是一个像莎士比亚一样说话的助手。",
		},
		{
			Role:    openai.ChatMessageRoleUser,
			Content: "给我讲个笑话",
		},
		{
			Role:    openai.ChatMessageRoleAssistant,
			Content: "鸡为什么过马路",
		},
		{
			Role:    openai.ChatMessageRoleUser,
			Content: "我不知道",
		},
	}

	resp, err := client.CreateChatCompletionWithMessage(context.TODO(), messages)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	res := resp.Choices[0].Message.Content
	fmt.Println(res)
}

func main() {
    client := newOpenAIClient()
	messages := []openai.ChatCompletionMessage{
		{
			Role:    openai.ChatMessageRoleSystem,
			Content: "你是个友好的聊天机器人",
		},
		{
			Role:    openai.ChatMessageRoleUser,
			Content: "Hi，我是Isa",
		},
	}

	resp, err := client.CreateChatCompletionWithMessage(context.TODO(), messages)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	res := resp.Choices[0].Message.Content
	fmt.Println(res)
}

func main() {
	client := newOpenAIClient()
	messages := []openai.ChatCompletionMessage{
		{
			Role: openai.ChatMessageRoleSystem,
			Content: `你是订餐机器人，为披萨餐厅自动收集订单信息。
你要首先问候顾客。然后等待用户回复收集订单信息。收集完信息需确认顾客是否还需要添加其他内容。
最后需要询问是否自取或外送，如果是外送，你要询问地址。最后告诉顾客订单总金额，并送上祝福。

请确保明确所有选项、附加项和尺寸，以便从菜单中识别出该项唯一的内容。
你的回应应该以简短、非常随意和友好的风格呈现。

菜单包括：

菜品价格：
意式辣香肠披萨（大、中、小） 12.95、10.00、7.00
芝士披萨（大、中、小） 10.95、9.25、6.50
茄子披萨（大、中、小） 11.95、9.75、6.75
薯条（大、小） 4.50、3.50
希腊沙拉 7.25

配料：
奶酪 2.00
蘑菇 1.50
香肠 3.00
加拿大熏肉 3.50
AI酱 1.50
辣椒 1.00

饮料：
可乐（大、中、小） 3.00、2.00、1.00
雪碧（大、中、小） 3.00、2.00、1.00
瓶装水 5.00`,
		},
		{
			Role:    openai.ChatMessageRoleAssistant,
			Content: "你好！欢迎来到披萨餐厅！您想点什么呢？",
		},
	}

	fmt.Printf("%s: %s\n", messages[1].Role, messages[1].Content)

	for {
		var s string
		fmt.Printf("user: ")
		_, err := fmt.Scanf("%s", &s)
		if err != nil {
			return
		}

		if s == "end" {
			break
		}

		messages = append(messages, openai.ChatCompletionMessage{
			Role:    openai.ChatMessageRoleUser,
			Content: s,
		})

		resp, err := client.CreateChatCompletionWithMessage(context.TODO(), messages)
		if err != nil {
			fmt.Printf("ChatCompletion error: %v\n", err)
			return
		}

		fmt.Printf("%s: %s\n", resp.Choices[0].Message.Role, resp.Choices[0].Message.Content)
		messages = append(messages, resp.Choices[0].Message)
	}
}

func main() {
	client := newOpenAIClient()
	messages := []openai.ChatCompletionMessage{
		{
			Role: openai.ChatMessageRoleSystem,
			Content: `你是订餐机器人，为披萨餐厅自动收集订单信息。
你要首先问候顾客。然后等待用户回复收集订单信息。收集完信息需确认顾客是否还需要添加其他内容。
最后需要询问是否自取或外送，如果是外送，你要询问地址。最后告诉顾客订单总金额，并送上祝福。

请确保明确所有选项、附加项和尺寸，以便从菜单中识别出该项唯一的内容。
你的回应应该以简短、非常随意和友好的风格呈现。

菜单包括：

菜品价格：
意式辣香肠披萨（大、中、小） 12.95、10.00、7.00
芝士披萨（大、中、小） 10.95、9.25、6.50
茄子披萨（大、中、小） 11.95、9.75、6.75
薯条（大、小） 4.50、3.50
希腊沙拉 7.25

配料：
奶酪 2.00
蘑菇 1.50
香肠 3.00
加拿大熏肉 3.50
AI酱 1.50
辣椒 1.00

饮料：
可乐（大、中、小） 3.00、2.00、1.00
雪碧（大、中、小） 3.00、2.00、1.00
瓶装水 5.00`,
		},
		{
			Role:    openai.ChatMessageRoleAssistant,
			Content: "你好！欢迎来到披萨餐厅！您想点什么呢？",
		},
	}

	fmt.Printf("%s: %s\n", messages[1].Role, messages[1].Content)

	for {
		var s string
		fmt.Printf("user: ")
		_, err := fmt.Scanf("%s", &s)
		if err != nil {
			return
		}

		if s == "end" {
			break
		}

		messages = append(messages, openai.ChatCompletionMessage{
			Role:    openai.ChatMessageRoleUser,
			Content: s,
		})

		resp, err := client.CreateChatCompletionWithMessage(context.TODO(), messages)
		if err != nil {
			fmt.Printf("ChatCompletion error: %v\n", err)
			return
		}

		fmt.Printf("%s: %s\n", resp.Choices[0].Message.Role, resp.Choices[0].Message.Content)
		messages = append(messages, resp.Choices[0].Message)
	}

	messages = append(messages, openai.ChatCompletionMessage{
		Role: openai.ChatMessageRoleSystem,
		Content: `创建上一个食品订单的json摘要。\
逐项列出每件商品的价格，字段应该是 1) 披萨，包括大小 2) 配料列表 3) 饮料列表，包括大小 4) 配菜列表包括大小 5) 总价
你应该给我返回一个可解析的json对象，包括上述字段`,
	})
	resp, err := client.CreateChatCompletionWithMessage(context.TODO(), messages)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

func main() {
	prompt := `
1+1是什么？
`
	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), prompt)
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	res := resp.Choices[0].Message.Content
	fmt.Println(res)
}

func main() {
	text := `
嗯呐，我现在可是火冒三丈，我那个搅拌机盖子竟然飞了出去，把我厨房的墙壁都溅上了果汁！
更糟糕的是，保修条款可不包括清理我厨房的费用。
伙计，赶紧给我过来！
`
	style := "正式普通话，用一个平静、尊敬、有礼貌的语调"
	prompt := `
把下面由两个双引号分隔的文本翻译成一种"%s"风格。
文本："%s"
`
	client := newOpenAIClient()
	resp, err := client.CreateChatCompletion(context.TODO(), fmt.Sprintf(prompt, style, text))
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
	res := resp.Choices[0].Message.Content
	fmt.Println(res)
}

from langchain_openai.chat_models import ChatOpenAI

api_key = "*******************"
openai_proxy = "https://api.***.com.cn/v1"

def main():
    chat =ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        openai_proxy=openai_proxy)
    print(chat)

if __name__ == "__main__":
    main()

from langchain_openai.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

api_key = "*******************"
openai_proxy = "https://api.***.com.cn/v1"

def main():
    customer_style = """正式普通话 \
    用一个平静、尊敬的语气
"""

    customer_email = """
    嗯呐，我现在可是火冒三丈，我那个搅拌机盖子竟然飞了出去，把我厨房的墙壁都溅上了果汁！
更糟糕的是，保修条款可不包括清理我厨房的费用。
伙计，赶紧给我过来！
"""

    template_string = """把由三个反引号分隔的文本\
翻译成一种{my_style}风格。\
文本: ```{my_text}```
"""
    # 使用提示模版，可以定义消息格式
    prompt_template = ChatPromptTemplate.from_template(template_string)
    customer_messages = prompt_template.format_messages(
        my_style = customer_style,
        my_text = customer_email
    )

    # 打印客户消息类型
    print("客户消息类型:",type(customer_messages),"\n")

    # 打印第一个客户消息类型
    print("第一个客户消息类型:", type(customer_messages[0]),"\n")

    # 打印第一个元素
    print("第一个客户消息: ", customer_messages[0],"\n")

if __name__ == "__main__":
    main()

from langchain_openai.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

api_key = "******"
openai_url = "https://api.***.com.cn/v1"

def main():
    customer_style = """正式普通话 \
    用一个平静、尊敬的语气
"""

    customer_email = """
    嗯呐，我现在可是火冒三丈，我那个搅拌机盖子竟然飞了出去，把我厨房的墙壁都溅上了果汁！
更糟糕的是，保修条款可不包括清理我厨房的费用。
伙计，赶紧给我过来！
"""

    template_string = """把由三个反引号分隔的文本\
翻译成一种{my_style}风格。\
文本: ```{my_text}```
"""
    # 使用提示模版
    prompt_template = ChatPromptTemplate.from_template(template_string)
    customer_messages = prompt_template.format_messages(
        my_style = customer_style,
        my_text = customer_email
    )

    chat = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url
    )
    # 强制转换类型
    openai_messages = chat(customer_messages)
    print(openai_messages.content)

if __name__ == "__main__":
    main()

from langchain_openai.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

api_key = "******"
openai_url = "https://api.***.com.cn/v1"

def main():
    service_style = """一个有礼貌的语气 \
    使用海盗风格
"""

    service_response = """嘿，顾客， \
保修不包括厨房的清洁费用， \
因为您在启动搅拌机之前 \
忘记盖上盖子而误用搅拌机, \
这是您的错。 \
倒霉！ 再见！
"""

    template_string = """把由三个反引号分隔的文本\
翻译成一种{my_style}风格。\
文本: ```{my_text}```
"""
    # 使用提示模版
    prompt_template = ChatPromptTemplate.from_template(template_string)
    customer_messages = prompt_template.format_messages(
        my_style = service_style,
        my_text = service_response
    )

    chat = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url
    )

    openai_messages = chat.invoke(customer_messages)
    print(openai_messages.content)

if __name__ == "__main__":
    main()

{
  "礼物": 是的,
  "交货天数": 5,
  "价钱": "很贵"
}

from langchain_openai.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

api_key = "******"
openai_url = "https://api.***.com.cn/v1"

def main():
    customer_review = """\
   这款吹叶机非常神奇。 它有四个设置：\
吹蜡烛、微风、风城、龙卷风。 \
两天后就到了，正好赶上我妻子的\
周年纪念礼物。 \
我想我的妻子会喜欢它到说不出话来。 \
到目前为止，我是唯一一个使用它的人，而且我一直\
每隔一天早上用它来清理草坪上的叶子。 \
它比其他吹叶机稍微贵一点，\
但我认为它的额外功能是值得的。 
"""

    template_string = """\
对于以下文本，请从中提取以下信息：

礼物：该商品是作为礼物送给别人的吗？ \
如果是，则回答 是的；如果否或未知，则回答 不是。

交货天数：产品需要多少天\
到达？ 如果没有找到该信息，则输出-1。

价钱：提取有关价值或价格的任何句子，\
并将它们输出为逗号分隔的 Python 列表。

使用以下键将输出格式化为 JSON：
礼物
交货天数
价钱

文本: {my_text}
"""
    # 使用提示模版
    prompt_template = ChatPromptTemplate.from_template(template_string)
    customer_messages = prompt_template.format_messages(
        my_text = customer_review
    )

    chat = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url
    )

    openai_messages = chat.invoke(customer_messages)
    print("结果类型：", type(openai_messages.content))
    print("结果：", openai_messages.content)

if __name__ == "__main__":
    main()

from langchain_openai.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.output_parsers import ResponseSchema, StructuredOutputParser

api_key = "******"
openai_url = "https://api.***.com.cn/v1"

def main():
    customer_review = """\
   这款吹叶机非常神奇。 它有四个设置：\
吹蜡烛、微风、风城、龙卷风。 \
两天后就到了，正好赶上我妻子的\
周年纪念礼物。 \
我想我的妻子会喜欢它到说不出话来。 \
到目前为止，我是唯一一个使用它的人，而且我一直\
每隔一天早上用它来清理草坪上的叶子。 \
它比其他吹叶机稍微贵一点，\
但我认为它的额外功能是值得的。 
"""

    template_string = """\
对于以下文本，请从中提取以下信息：

礼物：该商品是作为礼物送给别人的吗？
如果是，则回答 是的；如果否或未知，则回答 不是。

交货天数：产品到达需要多少天？ 如果没有找到该信息，则输出-1。

价钱：提取有关价值或价格的任何句子，并将它们输出为逗号分隔的Python列表。

文本: {my_text}

{format_instructions}
"""
    # 使用提示模版
    prompt_template = ChatPromptTemplate.from_template(template_string)

    # 使用输出解释器
    gift_schema = ResponseSchema(name="礼物", description="这件物品是作为礼物送给别人的吗？\
                            如果是，则回答 是的，\
                            如果否或未知，则回答 不是。")
    delivery_days_schema = ResponseSchema(name="交货天数",
                                      description="产品需要多少天才能到达？\
                                      如果没有找到该信息，则输出-1。")
    price_value_schema = ResponseSchema(name="价钱",
                                    description="提取有关价值或价格的任何句子，\
                                    并将它们输出为逗号分隔的Python列表")

    response_schemas = [gift_schema, delivery_days_schema, price_value_schema]
    output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
    format_instructions = output_parser.get_format_instructions()

    customer_messages = prompt_template.format_messages(
        my_text=customer_review,
        format_instructions=format_instructions
    )

    chat = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url
    )

    openai_messages = chat(customer_messages)
    output_dict = output_parser.parse(openai_messages.content)
    print("结果类型：", type(output_dict))
    print("结果：", output_dict)

if __name__ == "__main__":
    main()

from langchain_openai.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory

api_key = "******"
openai_url = "https://api.***.com.cn/v1"

def main():
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)
    memory = ConversationBufferMemory()

    conversation = ConversationChain(llm=llm, memory=memory, verbose=True)
    conversation.predict(input="你好，我叫特特鲁斯")
    conversation.predict(input="1+1等于多少？")
    conversation.predict(input="我叫什么名字？")
	conversation.predict(input="")

if __name__ == "__main__":
    main()

> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:
Human: 你好，我叫特特鲁斯
AI:  你好，特特鲁斯！很高兴认识你。我是一个人工智能程序，可以回答你的问题或者和你聊天。你有什么想知道的吗？
Human: 我叫什么名字
AI: 你叫特特鲁斯。很特别的名字！你知道吗，特特鲁斯这个名字在拉丁语中意味着“勇敢的战士”。很有力量的名字呢！有什么其他问题想问我吗？
Human: 1+1等于多少
AI: 1加1等于2。这是一个非常简单的数学问题，答案是2。如果你有其他数学问题或者其他想知道的事情，都可以问我哦！我会尽力回答你的。
Human: 
AI:

# memory.buffer_as_messages记忆了当前为止所有 的对话信息
print(memory.buffer_as_messages)
# load_memory_variables也可以打印缓存中的历史消息
print(memory.load_memory_variables({}))

[HumanMessage(content='你好，我叫特特鲁斯'), AIMessage(content=' 你好，特特鲁斯！很高兴认识你。我是一个人工智能助手，可以回答你的问题或者和你聊天。有什么我可以帮助你的吗？'), HumanMessage(content='我叫什么名字'), AIMessage(content='抱歉，我不知道你的名字。你可以告诉我吗？'), HumanMessage(content='1+1等于多少'), AIMessage(content='1加1等于2。您还有其他问题吗？'), HumanMessage(content=''), AIMessage(content='如果您有任何其他问题或者想要聊天，随时告诉我哦！我随时准备好帮助您。')]

{'history': 'Human: 你好，我叫特特鲁斯\nAI:  你好，特特鲁斯！我是一个AI助手，很高兴认识你。你有什么问题或者想要聊什么吗？\nHuman: 我叫什么名字\nAI: 你叫特特鲁斯。特特鲁斯是一个很独特的名字，听起来很有个性。你喜欢这个名字吗？如果你有任何其他问题或者想要聊什么，随时告诉我哦！\nHuman: 1+1等于多少\nAI: 1加1等于2。这是一个非常基本的数学问题，答案是2。如果你有任何其他数学问题或者其他想要了解的知识，都可以问我哦！我会尽力帮助你。\nHuman: \nAI: 你有任何其他问题或者想要聊什么吗？我可以提供各种信息和帮助。'}

from langchain_openai.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory

api_key = "******"
openai_url = "https://api.***.com.cn/v1"

def main():
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)
    memory = ConversationBufferMemory()
    memory.save_context({"input": "你好，我叫ice"}, {"output": "你好，我叫tracy"})
    
    conversation = ConversationChain(llm=llm, memory=memory, verbose=True)
    conversation.predict(input="你好，我叫特特鲁斯")
    conversation.predict(input="1+1等于多少？")
    conversation.predict(input="我叫什么名字？")
    conversation.predict(input="")
    print(memory.load_memory_variables({}))

if __name__ == "__main__":
    main()

> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:
Human: 你好，我叫ice
AI: 你好，我叫tracy
Human: 你好，我叫特特鲁斯
AI: 很高兴认识你，特特鲁斯！你有什么想要了解或者讨论的吗？
Human: 1+1等于多少？
AI: 1加1等于2。这是一个基本的数学问题，答案是2。您还有其他问题吗？
Human: 我叫什么名字？
AI: 您说您叫特特鲁斯。您的名字是特特鲁斯。有什么其他问题吗？
Human: 
AI:

> Finished chain.
{'history': 'Human: 你好，我叫ice\nAI: 你好，我叫tracy\nHuman: 你好，我叫特特鲁斯\nAI: 很高兴认识你，特特鲁斯！你有什么想要了解或者讨论的吗？\nHuman: 1+1等于多少？\nAI: 1加1等于2。这是一个基本的数学问题，答案是2。您还有其他问题吗？\nHuman: 我叫什么名字？\nAI: 您说您叫特特鲁斯。您的名字是特特鲁斯。有什么其他问题吗？\nHuman: \nAI: 您有什么其他问题或者想要讨论的吗？我可以提供各种信息和帮助。'}

from langchain_openai.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferWindowMemory

api_key = "xxxx"
openai_url = "https://api.xxx.com.cn/v1"

def main():
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)
    memory = ConversationBufferWindowMemory(k=1)
    memory.save_context({"input": "你好，我叫ice"}, {"output": "你好，我叫tracy"})
    memory.save_context({"input": "你好，朋友"}, {"output": "你好，我们一起玩吧"})
    print(memory.load_memory_variables({}))

if __name__ == "__main__":
    main()

from langchain_openai.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferWindowMemory

api_key = "xxxx"
openai_url = "https://api.chatanywhere.com.cn/v1"

def main():
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)
    memory = ConversationBufferWindowMemory(k=1)
    conversation = ConversationChain(llm=llm, memory=memory, verbose=True)
    conversation.predict(input="你好，我叫特特鲁斯")
    conversation.predict(input="1+1等于多少？")
    conversation.predict(input="我叫什么名字？")
    conversation.predict(input="")
    print(memory.load_memory_variables({}))

if __name__ == "__main__":
    main()

> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:
Human: 我叫什么名字？
AI: 抱歉，我无法知道你的名字，因为我是一个人工智能程序，无法获取你的个人信息。如果你有其他问题或需要帮助，请随时告诉我。
Human: 
AI:

> Finished chain.
{'history': 'Human: \nAI: 你好！有什么我可以帮助你的吗？'}

from langchain_openai.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationTokenBufferMemory

api_key = "sk-xxx"
openai_url = "https://api.chatanywhere.com.cn/v1"

def main():
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)
    memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=20)
    memory.save_context({"input": "你好，我叫ice"}, {"output": "你好，我叫tracy"})
    memory.save_context({"input": "你好，朋友"}, {"output": "你好，我们一起玩吧"})
    print(memory.load_memory_variables({}))

if __name__ == "__main__":
    main()

from langchain_openai.chat_models import ChatOpenAI
from langchain.memory import ConversationSummaryBufferMemory

api_key = "sk-xxx"
openai_url = "https://api.chatanywhere.com.cn/v1"

def main():
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)
    
    schedule = "在八点你和你的产品团队有一个会议。 \
你需要做一个PPT。 \
上午9点到12点你需要忙于LangChain。\
Langchain是一个有用的工具，因此你的项目进展的非常快。\
中午，在意大利餐厅与一位开车来的顾客共进午餐 \
走了一个多小时的路程与你见面，只为了解最新的 AI。 \
确保你带了笔记本电脑可以展示最新的 LLM 样例."

    memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=20)
    memory.save_context({"input": "你好，我叫ice"}, {"output": "你好，我叫tracy"})
    memory.save_context({"input": "你好，朋友"}, {"output": "你好，我们一起玩吧"})
    memory.save_context({"input": "今天的日程安排是什么？"}, {"output": f"{schedule}"})
    print(memory.load_memory_variables({}))

if __name__ == "__main__":
    main()

{'history': 'Human: 你好，我叫ice\nAI: 你好，我叫tracy\nHuman: 你好，朋友\nAI: 你好，我们一起玩吧\nHuman: 今天的日程安排是什么？\nAI: 在八点你和你的产品团队有一个会议。 你需要做一个PPT。 上午9点到12点你需要忙于LangChain。Langchain是一个有用的工具，因此你的项目进展的非常快。中午，在意大利餐厅与一位开车来的顾客共进午餐 走了一个多小时的路程与你见面，只为了解最新的 AI。 确保你带了笔记本电脑可以展示最新的 LLM 样例.'}

from langchain_openai.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationSummaryBufferMemory

api_key = "sk-xxx"
openai_url = "https://api.chatanywhere.com.cn/v1"

def main():
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)
    
    schedule = "在八点你和你的产品团队有一个会议。 \
你需要做一个PPT。 \
上午9点到12点你需要忙于LangChain。\
Langchain是一个有用的工具，因此你的项目进展的非常快。\
中午，在意大利餐厅与一位开车来的顾客共进午餐 \
走了一个多小时的路程与你见面，只为了解最新的 AI。 \
确保你带了笔记本电脑可以展示最新的 LLM 样例."

    memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=1000)
    memory.save_context({"input": "你好，我叫ice"}, {"output": "你好，我叫tracy"})
    memory.save_context({"input": "你好，朋友"}, {"output": "你好，我们一起玩吧"})
    memory.save_context({"input": "今天的日程安排是什么？"}, {"output": f"{schedule}"})

    conversation = ConversationChain(llm=llm, memory=memory, verbose=True)
    conversation.predict(input="展示什么样的样例最好呢")
    print(memory.load_memory_variables({}))

if __name__ == "__main__":
    main()

{'history': 'Human: 你好，我叫ice\nAI: 你好，我叫tracy\nHuman: 你好，朋友\nAI: 你好，我们一起玩吧\nHuman: 今天的日程安排是什么？\nAI: 在八点你和你的产品团队有一个会议。 你需要做一个PPT。 上午9点到12点你需要忙于LangChain。Langchain是一个有用的工具，因此你的项目进展的非常快。中午，在意大利餐厅与一位开车来的顾客共进午餐 走了一个多小时的路程与你见面，只为了解最新的 AI。 确保你带了笔记本电脑可以展示最新的 LLM 样例.\nHuman: 展示什么样的样例最好呢\nAI: 展示一些关于LangChain如何提高生产效率的案例会很有帮助。你可以展示一些实际的数据和结果，以及用户的反馈和体验。这样可以更直观地展示LangChain的价值和优势。希望这些建议对你有所帮助！'}

class BaseCallbackHandler(
    LLMManagerMixin,
    ChainManagerMixin,
    ToolManagerMixin,
    RetrieverManagerMixin,
    CallbackManagerMixin,
    RunManagerMixin,
)

class BaseCallbackHandler:
    """Base callback handler that can be used to handle callbacks from langchain."""

    def on_llm_start(
        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
    ) -> Any:
        """Run when LLM starts running."""

    def on_chat_model_start(
        self, serialized: Dict[str, Any], messages: List[List[BaseMessage]], **kwargs: Any
    ) -> Any:
        """Run when Chat Model starts running."""

    def on_llm_new_token(self, token: str, **kwargs: Any) -> Any:
        """Run on new LLM token. Only available when streaming is enabled."""

    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> Any:
        """Run when LLM ends running."""

    def on_llm_error(
        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
    ) -> Any:
        """Run when LLM errors."""

    def on_chain_start(
        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
    ) -> Any:
        """Run when chain starts running."""

    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> Any:
        """Run when chain ends running."""

    def on_chain_error(
        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
    ) -> Any:
        """Run when chain errors."""

    def on_tool_start(
        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
    ) -> Any:
        """Run when tool starts running."""

    def on_tool_end(self, output: Any, **kwargs: Any) -> Any:
        """Run when tool ends running."""

    def on_tool_error(
        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
    ) -> Any:
        """Run when tool errors."""

    def on_text(self, text: str, **kwargs: Any) -> Any:
        """Run on arbitrary text."""

    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
        """Run on agent action."""

    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> Any:
        """Run on agent end."""

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
from langchain_core.outputs import LLMResult
from langchain.callbacks.base import AsyncCallbackHandler, BaseCallbackHandler
from typing import Any, Dict, List
import asyncio
from pydantic import SecretStr

api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


class MyCustomSyncHandler(BaseCallbackHandler):
    def on_llm_new_token(self, token: str, **kwargs) -> None:
        print(
            f"Sync handler being called in a `thread_pool_executor`: token: {token}")


class MyCustomAsyncHandler(AsyncCallbackHandler):
    """Async callback handler that can be used to handle callbacks from langchain."""

    async def on_llm_start(
        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
    ) -> None:
        """Run when chain starts running."""
        print("zzzz....")
        await asyncio.sleep(0.3)
        class_name = serialized["name"]
        print("Hi! I just woke up. Your llm is starting")

    async def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
        """Run when chain ends running."""
        print("zzzz....")
        await asyncio.sleep(0.3)
        print("Hi! I just woke up. Your llm is ending")


async def main():
    # To enable streaming, we pass in `streaming=True` to the ChatModel constructor
    # Additionally, we pass in a list with our custom handler
    chat = ChatOpenAI(
        max_tokens=30,
        base_url=openai_url,
        api_key=api_key,
        streaming=True,
        callbacks=[MyCustomSyncHandler(), MyCustomAsyncHandler()],
    )

    await chat.agenerate([[HumanMessage(content="Tell me a joke")]])


if __name__ == "__main__":
    asyncio.run(main())

zzzz....
Hi! I just woke up. Your llm is starting
Sync handler being called in a `thread_pool_executor`: token: 
Sync handler being called in a `thread_pool_executor`: token: Why
Sync handler being called in a `thread_pool_executor`: token:  couldn
Sync handler being called in a `thread_pool_executor`: token: 't
Sync handler being called in a `thread_pool_executor`: token:  the
Sync handler being called in a `thread_pool_executor`: token:  bicycle
Sync handler being called in a `thread_pool_executor`: token:  stand
Sync handler being called in a `thread_pool_executor`: token:  up
Sync handler being called in a `thread_pool_executor`: token:  by
Sync handler being called in a `thread_pool_executor`: token:  itself
Sync handler being called in a `thread_pool_executor`: token: ?


Sync handler being called in a `thread_pool_executor`: token: Because
Sync handler being called in a `thread_pool_executor`: token:  it
Sync handler being called in a `thread_pool_executor`: token:  was
Sync handler being called in a `thread_pool_executor`: token:  two
Sync handler being called in a `thread_pool_executor`: token:  tired
Sync handler being called in a `thread_pool_executor`: token: !
Sync handler being called in a `thread_pool_executor`: token: 
zzzz....
Hi! I just woke up. Your llm is ending

from langchain_openai.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import LLMChain

api_key = "sk-xxx"
openai_url = "https://api.chatanywhere.com.cn/v1"

def main():
    # 1.初始化语言模型
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)
    # 2.初始化提示模版：接受一个名为product的变量。该prompt将要求LLM生成一个描述制造该产品的公司的最佳名称
    prompt = ChatPromptTemplate.from_template("描述制造{product}该产品的公司的最佳名称是什么")
    # 3.构建大语言模型链，链～=LLM+Prompt
    chain = LLMChain(llm=llm, prompt=prompt)
    # 4.运行大语言模型链
    product = "大号床单套装"
    print(chain.invoke(input={"product": product}).get('text'))

if __name__ == "__main__":
    main()

"豪华床品有限公司"

from langchain_openai.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import LLMChain, SimpleSequentialChain

api_key = "sk-xxx"
openai_url = "https://api.chatanywhere.com.cn/v1"

def main():
    # 1.初始化语言模型
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)
    # 2.初始化提示模版1：这个提示将接受产品并返回最佳名称来描述该公司
    prompt1 = ChatPromptTemplate.from_template("描述制造{product}该产品的公司的最佳名称是什么")
    # 3.初始化提示模版2：接受公司名称，然后输出该公司的长为20个单词的描述
    prompt2 = ChatPromptTemplate.from_template("写一个20个单词的描述对于这个公司：{company_name}")
    # 4.构建大语言模型子链，链～=LLM+Prompt
    chain_one = LLMChain(llm=llm, prompt=prompt1)
    chain_two = LLMChain(llm=llm, prompt=prompt2)
    # 5.构建一个简单顺序链，把两个子链组合起来
    simple_chain = SimpleSequentialChain(chains=[chain_one, chain_two], verbose=True)
    # 6.运行简单顺序链
    product = "大号床单套装"
    simple_chain.invoke(product)

if __name__ == "__main__":
    main()

> Entering new SimpleSequentialChain chain...
"豪华床品有限公司"
"豪华床品有限公司"提供高品质、舒适的床上用品，让您享受豪华睡眠体验，提升生活品质。

from langchain_openai.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import LLMChain, SequentialChain

api_key = "sk-xxx"
openai_url = "https://api.chatanywhere.com.cn/v1"

def main():
    # 1.初始化语言模型
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)
    # 2.子链1: 翻译成英语
    prompt1 = ChatPromptTemplate.from_template(
        "把下面的文本翻译成英文: \n"
        "{review}"
    )
    chain_one = LLMChain(llm=llm, prompt=prompt1, output_key="english_review")
    # 2.子链2: 用一句话总结下面的文本
    prompt2 = ChatPromptTemplate.from_template(
        "用一句话总结下面的文本：\n"
        "{english_review}"
    )
    chain_two = LLMChain(llm=llm, prompt=prompt2, output_key="summary")
    # 4.子链3: 下面文本使用什么语言
    prompt3 = ChatPromptTemplate.from_template(
        "下面的文本使用的是什么语言：\n"
        "{review}"
    )
    chain_three = LLMChain(llm=llm, prompt=prompt3, output_key="language")
    # 4.子链4: 使用特定的语言对下面的总结写一个后续回复
    prompt4 = ChatPromptTemplate.from_template(
        "使用特定的语言对下面的总结写一个后续回复：\n"
        "总结: {summary}\n语言: {language}"
    )
    chain_four = LLMChain(llm=llm, prompt=prompt4, output_key="followup_message")
    # 5.构建一个顺序链，把4个子链组合起来
    chain = SequentialChain(
        chains=[chain_one, chain_two, chain_three, chain_four],
        input_variables=["review"],
        output_variables=["english_review","summary", "followup_message"],
        verbose=True,
        return_all=True)
    # 6.运行顺序链
    review = "Kubernetes 和更广泛的容器生态系统正发展为通用计算平台和生态系统，\
    可以媲美甚至超越虚拟机 (VM)，作为现代云基础设施和应用程序的基本构建块。\
    该生态系统使组织能够提供高生产力的平台即服务 (PaaS)，\
    解决围绕云原生开发的多个基础设施相关和操作相关任务与问题，\
    以便开发团队专注于编码和创新"
    print(chain.invoke(review))
     
if __name__ == "__main__":
    main()

{'review': 'Kubernetes 和更广泛的容器生态系统正发展为通用计算平台和生态系统，    可以媲美甚至超越虚拟机 (VM)，作为现代云基础设施和应用程序的基本构建块。    该生态系统使组织能够提供高生产力的平台即服务 (PaaS)，    解决围绕云原生开发的多个基础设施相关和操作相关任务与问题，    以便开发团队专注于编码和创新', 'english_review': 'Kubernetes and the broader container ecosystem are evolving into a universal computing platform and ecosystem that can rival or even surpass virtual machines (VMs) as the fundamental building blocks of modern cloud infrastructure and applications. This ecosystem enables organizations to deliver highly productive platform-as-a-service (PaaS), addressing multiple infrastructure and operational tasks and issues related to cloud-native development, allowing development teams to focus on coding and innovation.', 'summary': 'Kubernetes and containers are becoming the new standard for cloud infrastructure, enabling organizations to focus on coding and innovation.', 'followup_message': '非常赞同这个总结！Kubernetes和容器正在成为云基础设施的新标准，让组织能够更专注于编码和创新。这种趋势对于推动技术发展和提高效率都有着重要的作用。希望更多的企业能够采用这些先进的技术，实现更快速的发展和创新。'}

from langchain_openai.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate, PromptTemplate
from langchain.chains import LLMChain
from langchain.chains.router import MultiPromptChain
from langchain.chains.router.llm_router import LLMRouterChain
from langchain.chains.router.llm_router import RouterOutputParser


api_key = "sk-xxx"
openai_url = "https://api.chatanywhere.com.cn/v1"


def main():
    # 1.初始化语言模型
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    # 2.初始化物理问题提示模版
    physics_template = """你是一个非常聪明的物理专家\
你擅长用一种简洁并且易于理解的方式去回答问题\
当你不知道问题的答案时，你承认\
你不知道.

这是一个问题:
{input}
"""
    # 3.初始化数学问题提示模版
    math_template = """你是一个非常优秀的数学家。\
你擅长回答数学问题。\
你之所以如此优秀,\
是因为你能够将棘手的问题分解为组成部分,\
回答组成部分，然后将它们组合在一起，回答更广泛的问题。

这是一个问题：
{input}
"""

    # 4.初始化历史问题提示模版
    history_template = """你是以为非常优秀的历史学家。\
你对一系列历史时期的人物、事件和背景有着极好的学识和理解\
你有能力思考、反思、辩证、讨论和评估过去。\
你尊重历史证据，并有能力利用它来支持你的解释和判断。

这是一个问题:
{input}
"""

    # 5.初始化计算机问题提示模版
    computerscience_template = """你是一个成功的计算机科学专家。\
你有创造力、协作精神、\
前瞻性思维、自信、解决问题的能力、\
对理论和算法的理解以及出色的沟通技巧。\
你非常擅长回答编程问题。\
你之所以如此优秀，是因为你知道\
如何通过以机器可以轻松解释的命令式步骤描述解决方案来解决问题,\
并且你知道如何选择在时间复杂性和空间复杂性之间取得良好平衡的解决方案。

这是一个问题:
{input}
"""

    # 6.对上述提示模版进行命名和描述，这些信息传递给路由链，路由链决定使用哪个子链
    prompt_infos = [
        {
            "name": "物理学",
            "desc": "擅长回答关于物理学的问题",
            "prompt_template": physics_template
        },
        {
            "name": "数学",
            "desc": "擅长回答数学问题",
            "prompt_template": math_template
        },
        {
            "name": "历史",
            "desc": "擅长回答历史问题",
            "prompt_template": history_template
        },
        {
            "name": "计算机科学",
            "desc": "擅长回答计算机科学问题",
            "prompt_template": computerscience_template
        }
    ]

    # 7.基于提示模版信息创建对应的目的链
    destination_chains = {}
    for p_info in prompt_infos:
        name = p_info["name"]
        prompt_tempalte = p_info["prompt_template"]
        prompt = ChatPromptTemplate.from_template(
            template=prompt_tempalte)
        chain = LLMChain(
            llm=llm,
            prompt=prompt,
        )
        destination_chains[name] = chain

    destinations = [f"{p['name']}: {p['desc']}" for p in prompt_infos]
    destinations_str = "\n".join(destinations)

    # 8.创建默认目的链，类似路由表中的默认路由
    default_prompt = ChatPromptTemplate.from_template("{input}")
    default_chain = LLMChain(
        llm=llm,
        prompt=default_prompt,
    )

    # 9.定义不同链之间的路由模版，返回的格式要求为什么是destination和next_inputs，
    # 跟RouterOutputParser相绑定的。为什么是4个花括号?因为要进行两次format，两个花括号相当于输出一个花括号
    MULTI_PROMPT_ROUTER_TEMPLATE = """
给语言模型一个原始文本输入,\
让其选择最适合输入的模型提示.\
系统将为您提供可用提示的名称以及最适合改提示的描述\
如果你认为修改原始输入最终会导致语言模型做出更好的响应,\
你也可以修改原始输入.

<< 格式 >>
返回一个带有JSON对象的markdown代码片段, 该JSON对象的格式如下:
```json
{{{{
    "destination": string 使用提示名字或者使用"DEFAULT"
    "next_inputs": string 原始输入的改进版本
}}}}
```

记住："destination"必须是下面指定的候选提示名称之一, \
或者如果输入不太适合任何候选提示, \
则可以是"DEFAULT"。\
记住:如果您认为不需要任何修改, \
则"next_inputs"可以只是原始输入。

<< 候选提示 >>
{destinations}

<< 输入 >>
{{input}}
"""

    # 10.构建路由链
    router_template = MULTI_PROMPT_ROUTER_TEMPLATE.format(
        destinations=destinations_str
    )
    print(router_template)
    print(router_template)

    router_prompt = PromptTemplate(
        template=router_template,
        input_variables=["input"],
    )
    router_prompt.output_parser = RouterOutputParser()

    router_chain = LLMRouterChain.from_llm(llm, router_prompt)

    # 11.创建多提示链
    chain = MultiPromptChain(
        router_chain=router_chain,
        destination_chains=destination_chains,
        default_chain=default_chain,
        verbose=True,
    )

    # 12.运行路由链
    print(chain.invoke(input={"input": "1+3等于多少?"}))
    print(chain.invoke(input={"input": "黑洞是什么?"}))
    print(chain.invoke(input={"input": "五代十国是什么?"}))
    print(chain.invoke(input={"input": "最流行的编程语言是什么?"}))
    print(chain.invoke(input={"input": "你喜欢什么?"}))


if __name__ == "__main__":
    main()

> Entering new MultiPromptChain chain...
数学: {'input': '1 + 3 等于多少?'}
> Finished chain.
{'input': '1 + 3 等于多少?', 'text': '1 + 3 = 4.'}


> Entering new MultiPromptChain chain...
物理学: {'input': '黑洞是什么?'}
> Finished chain.
{'input': '黑洞是什么?', 'text': '黑洞是宇宙中一种非常密集的天体，它的引力非常强大，甚至连光都无法逃离它的吸引力。黑洞形成于恒星死亡时，其质量非常大，体积非常小，因此被称为“黑洞”。在黑洞的事件视界内，引力非常强大，甚至时间和空间都会被扭曲。目前科学家对黑洞的研究仍在进行中，仍有很多未解之谜。'}


> Entering new MultiPromptChain chain...
历史: {'input': '五代十国是中国历史上的一个时期，指的是五代时期和十国时期的合称。'}
> Finished chain.
{'input': '五代十国是中国历史上的一个时期，指的是五代时期和十国时期的合称。', 'text': '请问你对五代十国时期的政治、经济和文化特点有什么深入的见解和分析？你认为这个时期对中国历史的发展有着怎样的影响？'}


> Entering new MultiPromptChain chain...
计算机科学: {'input': '最流行的编程语言是什么?'}
> Finished chain.
{'input': '最流行的编程语言是什么?', 'text': '目前最流行的编程语言之一是Python。Python是一种简单易学、功能强大的编程语言，被广泛用于数据科学、人工智能、Web开发等领域。它具有丰富的库和工具，使得开发人员可以快速高效地完成各种任务。另外，JavaScript、Java、C++、C#等编程语言也在不同领域有着广泛的应用和较高的流行度。'}


> Entering new MultiPromptChain chain...
None: {'input': '你喜欢什么?'}
> Finished chain.
{'input': '你喜欢什么?', 'text': '作为一个AI助手，我没有情感和喜好，我只是一个程序，可以帮助您解决问题和提供信息。请问有什么可以帮助您的吗？'}

from langchain_openai.chat_models import ChatOpenAI
from langchain_community.document_loaders.csv_loader import CSVLoader
from langchain_community.vectorstores.docarray import DocArrayInMemorySearch
from langchain_openai import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from pydantic import SecretStr

api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


def main():
    # 使用LangChain文档加载器csv类型对数据进行导入, csv表格自造数据
    file = "/Users/iceyao/Desktop/test_101.csv"
    csv_loader = CSVLoader(file_path=file)
    docs = csv_loader.load()

    # 使用OpenAI的向量嵌入
    embedding = OpenAIEmbeddings(
        api_key=api_key,
        base_url=openai_url)

    # 初始化向量存储，文档列表、向量嵌入作为参数
    vector_db = DocArrayInMemorySearch.from_documents(docs, embedding)

    # 使用OpenAI语言模型
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    # 使用检索问答链来回答问题，基于向量存储创建检索器
    retriever = vector_db.as_retriever()

    # from_chain_type参数说明：
    # llm：语言模型
    # retriever：检索器
    # chain_type：链类型
    # chain_type = stuff, 是将所有查询得到的文档组合成一个文档传入下一步
    # chain_type = map_reduce, 将所有块与问题一起传递给语言模型，获取回复，使用另一个语言模型调用将所有单独的回复总结成最终答案，它可以在任意数量的文档上运行。可以并行处理单个问题，同时也需要更多的调用。它将所有文档视为独立的
    # chain_type = refine, 用于循环许多文档，际上是迭代的，建立在先前文档的答案之上，非常适合前后因果信息并随时间逐步构建答案，依赖于先前调用的结果。它通常需要更长的时间，并且基本上需要与map_reduce一样多的调用
    # chain_type = map_rerank, 对每个文档进行单个语言模型调用，要求它返回一个分数，选择最高分，这依赖于语言模型知道分数应该是什么，需要告诉它，如果它与文档相关，则应该是高分
    retrieva_qa = RetrievalQA.from_chain_type(
        llm=llm,
        retriever=retriever,
        chain_type="stuff",
        verbose=True,
    )
    query = "请用markdown表格的方式列出所有跟云相关的标题，并对每个标题进行抽象总结"
    result = retrieva_qa({"query": query})
    print(result['result'])


if __name__ == "__main__":
    main()

from langchain_community.document_loaders.csv_loader import CSVLoader
from langchain.indexes import VectorstoreIndexCreator
from langchain_community.vectorstores.docarray import DocArrayInMemorySearch
from langchain_openai import OpenAIEmbeddings
from pydantic import SecretStr

api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


def main():
    # 1.初始化语言模型
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    # 2.使用LangChain文档加载器csv类型对数据进行导入, csv数据可以自行创造
    file = "/Users/iceyao/Desktop/test_101.csv"
    csv_loader = CSVLoader(file_path=file)

    # 3.基于文档加载器创建LangChain向量存储索引，这里使用向量内存存储
    index = VectorstoreIndexCreator(
        vectorstore_cls=DocArrayInMemorySearch,
        embedding=OpenAIEmbeddings(
            api_key=api_key,
            base_url=openai_url)).from_loaders([csv_loader])

    # 4.查询创建的向量存储，问题要跟csv内容有所关联
    query = "请用markdown表格的方式列出所有跟云相关的标题，并对每个标题进行抽象总结"
    response = index.query(question=query, llm=llm)

    print(response)


if __name__ == "__main__":
    main()

from langchain_openai.chat_models import ChatOpenAI
from langchain_community.document_loaders.csv_loader import CSVLoader
from langchain_community.vectorstores.docarray import DocArrayInMemorySearch
from langchain_openai import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from pydantic import SecretStr

api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


def main():
    # 使用LangChain文档加载器csv类型对数据进行导入
    file = "/Users/iceyao/Desktop/test_101.csv"
    csv_loader = CSVLoader(file_path=file)
    docs = csv_loader.load()

    # 使用OpenAI的向量嵌入
    embedding = OpenAIEmbeddings(
        api_key=api_key,
        base_url=openai_url)

    # 初始化向量存储，文档列表、向量嵌入作为参数
    vector_db = DocArrayInMemorySearch.from_documents(docs, embedding)

    # 返回一个文档列表，默认返回4个最相近语义的文档
    docs = vector_db.similarity_search("推荐一篇跟存储相关的文章")
    print("返回文档的数量：{0}\n".format(len(docs)))
    print("第一个文档是：{0}\n".format(docs[0]))
    print("第二个文档是：{0}\n".format(docs[1]))

    # 使用OpenAI语言模型
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    # 把返回的文档列表，构造成提示发送给语言模型来回答
    qdocs = "".join([docs[i].page_content for i in range(len(docs))])
    response = llm.invoke(
        input=f"{qdocs}问题：请用markdown表格的方式列出所有跟云相关的标题，并对每个标题进行抽象总结")
    print(response.content)

    # 使用检索问答链来回答问题，基于向量存储创建检索器
    retriever = vector_db.as_retriever()

    retrieva_qa = RetrievalQA.from_chain_type(
        llm=llm,
        retriever=retriever,
        chain_type="stuff",
        verbose=True,
    )
    query = "请用markdown表格的方式列出所有跟云相关的标题，并对每个标题进行抽象总结"
    result = retrieva_qa({"query": query})
    print(result['result'])


if __name__ == "__main__":
    main()

from langchain_openai.chat_models import ChatOpenAI
from langchain_community.document_loaders.csv_loader import CSVLoader
from pydantic import SecretStr

api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


def main():
    # 使用LangChain文档加载器csv类型对数据进行导入
    file = "/Users/iceyao/Desktop/test_101.csv"
    csv_loader = CSVLoader(file_path=file)
    docs = csv_loader.load()

    # 使用OpenAI语言模型
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    # 打印几条样本数据
    for i in range(len(docs[0:5])):
        print(docs[i].page_content + "\n")


if __name__ == "__main__":
    main()

产品名称: 应收账款质押融资
产品类型: 动产融资
产品简介: 以应收账款为质押品获取融资
适用场景: 核心企业、中小企业
融资主体: 核心企业、中小企业
融资额度: 100万元以上
融资期限: 1个月-3年
融资成本: 5%-8%
担保方式: 应收账款质押、信用担保、保证担保等
风险控制: 应收账款真实性、债权清晰性、履约能力等
优势: 融资便捷、成本较低、提高资金利用率
案例: 某大型制造企业利用应收账款质押融资，获得了1000万元的流动资金，用于采购原材料，有效缓解了资金压力，促进生产经营。

产品名称: 仓单融资
产品类型: 动产融资
产品简介: 以仓单为质押品获取融资
适用场景: 核心企业、中小企业
融资主体: 核心企业、中小企业
融资额度: 100万元以上
融资期限: 1个月-3年
融资成本: 4%-7%
担保方式: 仓单质押、信用担保、保证担保等
风险控制: 货物真实性、权属清晰性、仓储安全等
优势: 融资便捷、成本较低、盘活存货资产
案例: 某贸易企业利用仓单融资，获得了500万元的流动资金，用于扩大进出口业务，提高了资金周转效率。

产品名称: 订单融资
产品类型: 信用融资
产品简介: 以订单为基础获取融资
适用场景: 核心企业、中小企业
融资主体: 核心企业、中小企业
融资额度: 100万元以上
融资期限: 1个月-1年
融资成本: 3%-6%
担保方式: 订单真实性、买方信用状况等
风险控制: 订单池管理、风险分散等
优势: 融资便捷、成本较低、提升供应链协同效率
案例: 某电商企业利用订单融资，获得了2000万元的流动资金，用于备货发货，满足了订单快速增长的需求。

产品名称: 动产抵押融资
产品类型: 动产融资
产品简介: 以动产（如设备、车辆等）为质押品获取融资
适用场景: 中小企业
融资主体: 中小企业
融资额度: 50万元以上
融资期限: 1个月-3年
融资成本: 5%-8%
担保方式: 动产抵押、信用担保、保证担保等
风险控制: 动产权属清晰性、评估价值等
优势: 融资便捷、提高资产利用率
案例: 某科技企业利用动产抵押融资，获得了100万元的流动资金，用于研发新产品，提升了企业竞争力。

产品名称: 保单融资
产品类型: 信用融资
产品简介: 以保单为质押品获取融资
适用场景: 核心企业、中小企业
融资主体: 核心企业、中小企业
融资额度: 100万元以上
融资期限: 1个月-1年
融资成本: 3%-6%
担保方式: 保单质押、信用担保、保证担保等
风险控制: 保单真实性、保费支付记录等
优势: 融资便捷、成本较低、盘活保单资产
案例: 某制造企业利用保单融资，获得了500万元的流动资金，用于采购原材料，降低了融资成本。

手动创建问题和答案 -> 使用LLM自动创建问答测试用例 -> 使用同一个LLM回答 -> 让另一个LLM进行答案判断

from langchain_openai.chat_models import ChatOpenAI
from langchain_community.document_loaders.csv_loader import CSVLoader
from langchain.evaluation.qa import QAGenerateChain
from langchain.base_language import BaseLanguageModel
from langchain.prompts import PromptTemplate
from typing import Any

from pydantic import SecretStr

api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


template = """You are a teacher coming up with questions to ask on a quiz.
Given the following document, please generate a question and answer based on that document.

Example Format:
<Begin Document>
...
<End Document>
QUESTION: question here
ANSWER: answer here

These questions should be detailed and be based explicitly on information in the document. Begin!

<Begin Document>
{doc}
<End Document>
请使用中文输出
"""
PROMPT = PromptTemplate(
    input_variables=["doc"],
    template=template,
)


# 继承QAGenerateChain，重写from_llm方法
class ZhCNQAGenerateChain(QAGenerateChain):
    """LLM Chain for generating examples for question answering."""

    @classmethod
    def from_llm(cls, llm: BaseLanguageModel, **kwargs: Any) -> QAGenerateChain:
        """Load QA Generate Chain from LLM."""
        return cls(llm=llm, prompt=PROMPT, **kwargs)


def main():
    # 使用LangChain文档加载器csv类型对数据进行导入
    file = "/Users/iceyao/Desktop/test_101.csv"
    csv_loader = CSVLoader(file_path=file)
    docs = csv_loader.load()

    # 使用OpenAI语言模型
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)


    # 创建ZhCNQAGenerateChain链
    sample_qa_chain = ZhCNQAGenerateChain.from_llm(llm)

    # 调用apply方法自动创建问答对
    examples = sample_qa_chain.apply([{"doc": t} for t in docs])

    # 打印问答对
    for i in examples:
        print(i['qa_pairs'])


if __name__ == "__main__":
    main()

{'query': '什么是“应收账款质押融资”产品的主要特点和优势？ ', 'answer': '“应收账款质押融资”产品的主要特点包括产品类型为动产融资，适用场景为核心企业和中小企业，融资额度为100万元以上，融资期限为1个月至3年，融资成本为5%-8%，担保方式包括应收账款质押、信用担保、保证担保等。其优势在于融资便捷、成本较低、提高资金利用率。'}
{'query': '仓单融资产品的适用场景是什么？融资主体是谁？融资额度和期限分别是多少？融资成本是多少？担保方式有哪些？', 'answer': '仓单融资产品适用于核心企业和中小企业。融资主体也是核心企业和中小企业。融资额度为100万元以上，融资期限为1个月至3年。融资成本为4%-7%。担保方式包括仓单质押、信用担保、保证担保等。'}
{'query': '什么是订单融资的产品简介和适用场景？融资额度和期限是多少？融资成本是多少？担保方式和风险控制措施是什么？', 'answer': '订单融资是以订单为基础获取融资的信用融资产品，适用于核心企业和中小企业。融资额度为100万元以上，融资期限为1个月至1年，融资成本为3%-6%。担保方式包括订单真实性和买方信用状况等，风险控制措施包括订单池管理和风险分散。'}
{'query': '什么是动产抵押融资的产品类型和适用场景？', 'answer': '动产抵押融资的产品类型是动产融资，适用场景是中小企业。'}
{'query': '保单融资产品的适用场景是什么？融资主体是谁？融资额度和期限分别是多少？', 'answer': '保单融资产品适用于核心企业和中小企业，融资主体也是核心企业和中小企业。融资额度为100万元以上，融资期限为1个月至1年。'}
{'query': '流水贷款的产品类型是什么？融资额度是多少？融资期限是多久？', 'answer': '流水贷款的产品类型是信用融资，融资额度为100万元以上，融资期限为1个月至3年。'}

# flake8: noqa
from langchain.globals import set_debug
from langchain_openai.chat_models import ChatOpenAI
from langchain_community.document_loaders.csv_loader import CSVLoader
from langchain_community.vectorstores.docarray import DocArrayInMemorySearch
from langchain_openai import OpenAIEmbeddings
from langchain.indexes import VectorstoreIndexCreator
from langchain.chains import RetrievalQA
from langchain.evaluation.qa import QAGenerateChain
from langchain.base_language import BaseLanguageModel
from langchain.prompts import PromptTemplate
from typing import Any

from pydantic import SecretStr

api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


template = """You are a teacher coming up with questions to ask on a quiz.
Given the following document, please generate a question and answer based on that document.

Example Format:
<Begin Document>
...
<End Document>
QUESTION: question here
ANSWER: answer here

These questions should be detailed and be based explicitly on information in the document. Begin!

<Begin Document>
{doc}
<End Document>
请使用中文输出
"""
PROMPT = PromptTemplate(
    input_variables=["doc"],
    template=template,
)

examples = [
    {
        'query': '仓单融资的产品的优点是什么?',
        'answer': '成本低、操作便捷'
    },
    {
        'query': '订单融资产品适用哪些企业?',
        'answer': '有实力的核心企业，还有一些中小企业'
    }
]


# 继承QAGenerateChain，重写from_llm方法
class ZhCNQAGenerateChain(QAGenerateChain):
    """LLM Chain for generating examples for question answering."""

    @classmethod
    def from_llm(cls, llm: BaseLanguageModel, **kwargs: Any) -> QAGenerateChain:
        """Load QA Generate Chain from LLM."""
        return cls(llm=llm, prompt=PROMPT, **kwargs)


def main():
    # 开启LangChain全局debug
    set_debug(True)

    # 使用LangChain文档加载器csv类型对数据进行导入
    file = "/Users/iceyao/Desktop/test_101.csv"
    csv_loader = CSVLoader(file_path=file)
    docs = csv_loader.load()

    # 基于文档加载器创建LangChain向量存储索引，这里使用向量内存存储
    index = VectorstoreIndexCreator(
        vectorstore_cls=DocArrayInMemorySearch,
        embedding=OpenAIEmbeddings(
            api_key=api_key,
            base_url=openai_url)).from_loaders([csv_loader])

    # 使用OpenAI语言模型
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    # 创建检索QA链
    retrieval_qa_chain = RetrievalQA.from_chain_type(
        llm=llm,
        retriever=index.vectorstore.as_retriever(),
        chain_type="stuff",
        verbose=True,
    )

    # 创建ZhCNQAGenerateChain链
    sample_qa_chain = ZhCNQAGenerateChain.from_llm(llm)

    # 调用apply方法自动创建问答对
    llm_examples = sample_qa_chain.apply([{"doc": t} for t in docs])

    # 整合测试用例，将手动测试用例和LLM测试用例合并
    llm_examples = [v for item in llm_examples for _, v in item.items()]
    new_examples = examples + llm_examples
    # 打印手动测试用例的第一个问题的LLM答案
    print(retrieval_qa_chain.invoke({"query": examples[0]['query']})) # type: ignore[misc]


if __name__ == "__main__":
    main()

[chain/start] [1:chain:ZhCNQAGenerateChain] Entering Chain run with input:
[inputs]
[llm/start] [1:chain:ZhCNQAGenerateChain > 2:llm:ChatOpenAI] Entering LLM run with input:
{
  "prompts": [
    "Human: You are a teacher coming up with questions to ask on a quiz.\nGiven the following document, please generate a question and answer based on that document.\n\nExample Format:\n<Begin Document>\n...\n<End Document>\nQUESTION: question here\nANSWER: answer here\n\nThese questions should be detailed and be based explicitly on information in the document. Begin!\n\n<Begin Document>\npage_content='\\ufeff产品名称: 应收账款质押融资\\n产品类型: 动产融资\\n产品简介: 以应收账款为质押品获取融资\\n适用场景: 核心企业、中小企业\\n融资主体: 核心企业、中小企业\\n融资额度: 100万元以上\\n融资期限: 1个月-3年\\n融资成本: 5%-8%\\n担保方式: 应收账款质押、信用担保、保证担保等\\n风险控制: 应收账款真实性、债权清晰性、履约能力等\\n优势: 融资便捷、成本较低、提高资金利用率\\n案例: 某大型制造企业利用应收账款质押融资，获得了1000万元的流动资金，用于采购原材料，有效缓解了资金压力，促进生产经营。' metadata={'source': '/Users/iceyao/Desktop/test_101.csv', 'row': 0}\n<End Document>\n请使用中文输出"
  ]
}
[llm/start] [1:chain:ZhCNQAGenerateChain > 3:llm:ChatOpenAI] Entering LLM run with input:
{
  "prompts": [
    "Human: You are a teacher coming up with questions to ask on a quiz.\nGiven the following document, please generate a question and answer based on that document.\n\nExample Format:\n<Begin Document>\n...\n<End Document>\nQUESTION: question here\nANSWER: answer here\n\nThese questions should be detailed and be based explicitly on information in the document. Begin!\n\n<Begin Document>\npage_content='\\ufeff产品名称: 仓单融资\\n产品类型: 动产融资\\n产品简介: 以仓单为质押品获取融资\\n适用场景: 核心企业、中小企业\\n融资主体: 核心企业、中小企业\\n融资额度: 100万元以上\\n融资期限: 1个月-3年\\n融资成本: 4%-7%\\n担保方式: 仓单质押、信用担保、保证担保等\\n风险控制: 货物真实性、权属清晰性、仓储安全等\\n优势: 融资便捷、成本较低、盘活存货资产\\n案例: 某贸易企业利用仓单融资，获得了500万元的流动资金，用于扩大进出口业务，提高了资金周转效率。' metadata={'source': '/Users/iceyao/Desktop/test_101.csv', 'row': 1}\n<End Document>\n请使用中文输出"
  ]
}
[llm/start] [1:chain:ZhCNQAGenerateChain > 4:llm:ChatOpenAI] Entering LLM run with input:
{
  "prompts": [
    "Human: You are a teacher coming up with questions to ask on a quiz.\nGiven the following document, please generate a question and answer based on that document.\n\nExample Format:\n<Begin Document>\n...\n<End Document>\nQUESTION: question here\nANSWER: answer here\n\nThese questions should be detailed and be based explicitly on information in the document. Begin!\n\n<Begin Document>\npage_content='\\ufeff产品名称: 订单融资\\n产品类型: 信用融资\\n产品简介: 以订单为基础获取融资\\n适用场景: 核心企业、中小企业\\n融资主体: 核心企业、中小企业\\n融资额度: 100万元以上\\n融资期限: 1个月-1年\\n融资成本: 3%-6%\\n担保方式: 订单真实性、买方信用状况等\\n风险控制: 订单池管理、风险分散等\\n优势: 融资便捷、成本较低、提升供应链协同效率\\n案例: 某电商企业利用订单融资，获得了2000万元的流动资金，用于备货发货，满足了订单快速增长的需求。' metadata={'source': '/Users/iceyao/Desktop/test_101.csv', 'row': 2}\n<End Document>\n请使用中文输出"
  ]
}
[llm/start] [1:chain:ZhCNQAGenerateChain > 5:llm:ChatOpenAI] Entering LLM run with input:
{
  "prompts": [
    "Human: You are a teacher coming up with questions to ask on a quiz.\nGiven the following document, please generate a question and answer based on that document.\n\nExample Format:\n<Begin Document>\n...\n<End Document>\nQUESTION: question here\nANSWER: answer here\n\nThese questions should be detailed and be based explicitly on information in the document. Begin!\n\n<Begin Document>\npage_content='\\ufeff产品名称: 动产抵押融资\\n产品类型: 动产融资\\n产品简介: 以动产（如设备、车辆等）为质押品获取融资\\n适用场景: 中小企业\\n融资主体: 中小企业\\n融资额度: 50万元以上\\n融资期限: 1个月-3年\\n融资成本: 5%-8%\\n担保方式: 动产抵押、信用担保、保证担保等\\n风险控制: 动产权属清晰性、评估价值等\\n优势: 融资便捷、提高资产利用率\\n案例: 某科技企业利用动产抵押融资，获得了100万元的流动资金，用于研发新产品，提升了企业竞争力。' metadata={'source': '/Users/iceyao/Desktop/test_101.csv', 'row': 3}\n<End Document>\n请使用中文输出"
  ]
}
[llm/start] [1:chain:ZhCNQAGenerateChain > 6:llm:ChatOpenAI] Entering LLM run with input:
{
  "prompts": [
    "Human: You are a teacher coming up with questions to ask on a quiz.\nGiven the following document, please generate a question and answer based on that document.\n\nExample Format:\n<Begin Document>\n...\n<End Document>\nQUESTION: question here\nANSWER: answer here\n\nThese questions should be detailed and be based explicitly on information in the document. Begin!\n\n<Begin Document>\npage_content='\\ufeff产品名称: 保单融资\\n产品类型: 信用融资\\n产品简介: 以保单为质押品获取融资\\n适用场景: 核心企业、中小企业\\n融资主体: 核心企业、中小企业\\n融资额度: 100万元以上\\n融资期限: 1个月-1年\\n融资成本: 3%-6%\\n担保方式: 保单质押、信用担保、保证担保等\\n风险控制: 保单真实性、保费支付记录等\\n优势: 融资便捷、成本较低、盘活保单资产\\n案例: 某制造企业利用保单融资，获得了500万元的流动资金，用于采购原材料，降低了融资成本。' metadata={'source': '/Users/iceyao/Desktop/test_101.csv', 'row': 4}\n<End Document>\n请使用中文输出"
  ]
}
[llm/start] [1:chain:ZhCNQAGenerateChain > 7:llm:ChatOpenAI] Entering LLM run with input:
{
  "prompts": [
    "Human: You are a teacher coming up with questions to ask on a quiz.\nGiven the following document, please generate a question and answer based on that document.\n\nExample Format:\n<Begin Document>\n...\n<End Document>\nQUESTION: question here\nANSWER: answer here\n\nThese questions should be detailed and be based explicitly on information in the document. Begin!\n\n<Begin Document>\npage_content='\\ufeff产品名称: 流水贷款\\n产品类型: 信用融资\\n产品简介: 以企业历史经营数据为基础获取融资\\n适用场景: 核心企业、中小企业\\n融资主体: 核心企业、中小企业\\n融资额度: 100万元以上\\n融资期限: 1个月-3年\\n融资成本: 4%-7%\\n担保方式: 企业财务数据、经营状况等\\n风险控制: 信用评级、风险监控等\\n优势: 融资便捷、无需抵押、手续简便\\n案例: 某零售企业利用流水贷款，获得了200万元的流动资金，' metadata={'source': '/Users/iceyao/Desktop/test_101.csv', 'row': 5}\n<End Document>\n请使用中文输出"
  ]
}
[llm/end] [1:chain:ZhCNQAGenerateChain > 2:llm:ChatOpenAI] [17.97s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "QUESTION: 什么是\"应收账款质押融资\"的产品类型？融资主体是谁？融资额度和期限是多少？融资成本是多少？担保方式有哪些？\nANSWER: \"应收账款质押融资\"的产品类型是动产融资。融资主体可以是核心企业或中小企业。融资额度为100万元以上，融资期限为1个月至3年，融资成本为5%-8%。担保方式包括应收账款质押、信用担保、保证担保等。",
        "generation_info": {
          "finish_reason": "stop",
          "logprobs": null
        },
        "type": "ChatGeneration",
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "QUESTION: 什么是\"应收账款质押融资\"的产品类型？融资主体是谁？融资额度和期限是多少？融资成本是多少？担保方式有哪些？\nANSWER: \"应收账款质押融资\"的产品类型是动产融资。融资主体可以是核心企业或中小企业。融资额度为100万元以上，融资期限为1个月至3年，融资成本为5%-8%。担保方式包括应收账款质押、信用担保、保证担保等。",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "completion_tokens": 179,
      "prompt_tokens": 402,
      "total_tokens": 581
    },
    "model_name": "gpt-3.5-turbo",
    "system_fingerprint": "fp_4f0b692a78"
  },
  "run": null
}
[llm/end] [1:chain:ZhCNQAGenerateChain > 3:llm:ChatOpenAI] [17.97s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "QUESTION: 仓单融资产品的适用场景是什么？融资主体是谁？融资额度和期限分别是多少？融资成本是多少？担保方式有哪些？\nANSWER: 仓单融资产品适用于核心企业和中小企业。融资主体也是核心企业和中小企业。融资额度为100万元以上，融资期限为1个月至3年。融资成本为4%-7%。担保方式包括仓单质押、信用担保、保证担保等。",
        "generation_info": {
          "finish_reason": "stop",
          "logprobs": null
        },
        "type": "ChatGeneration",
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "QUESTION: 仓单融资产品的适用场景是什么？融资主体是谁？融资额度和期限分别是多少？融资成本是多少？担保方式有哪些？\nANSWER: 仓单融资产品适用于核心企业和中小企业。融资主体也是核心企业和中小企业。融资额度为100万元以上，融资期限为1个月至3年。融资成本为4%-7%。担保方式包括仓单质押、信用担保、保证担保等。",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "completion_tokens": 175,
      "prompt_tokens": 379,
      "total_tokens": 554
    },
    "model_name": "gpt-3.5-turbo",
    "system_fingerprint": "fp_4f0b692a78"
  },
  "run": null
}
[llm/end] [1:chain:ZhCNQAGenerateChain > 4:llm:ChatOpenAI] [17.97s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "QUESTION: 产品名称为什么是订单融资？产品类型是什么？产品简介是什么？\nANSWER: 产品名称是订单融资，因为该产品是以订单为基础获取融资。产品类型是信用融资。产品简介是以订单为基础获取融资。",
        "generation_info": {
          "finish_reason": "stop",
          "logprobs": null
        },
        "type": "ChatGeneration",
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "QUESTION: 产品名称为什么是订单融资？产品类型是什么？产品简介是什么？\nANSWER: 产品名称是订单融资，因为该产品是以订单为基础获取融资。产品类型是信用融资。产品简介是以订单为基础获取融资。",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "completion_tokens": 87,
      "prompt_tokens": 362,
      "total_tokens": 449
    },
    "model_name": "gpt-3.5-turbo",
    "system_fingerprint": "fp_4f0b692a78"
  },
  "run": null
}
[llm/end] [1:chain:ZhCNQAGenerateChain > 5:llm:ChatOpenAI] [17.97s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "QUESTION: 什么是动产抵押融资的产品类型和适用场景？融资主体是谁？融资额度和期限是多少？融资成本是多少？担保方式有哪些？\nANSWER: 动产抵押融资的产品类型是动产融资，适用场景是中小企业。融资主体是中小企业，融资额度为50万元以上，融资期限为1个月至3年，融资成本为5%-8%。担保方式包括动产抵押、信用担保、保证担保等。",
        "generation_info": {
          "finish_reason": "stop",
          "logprobs": null
        },
        "type": "ChatGeneration",
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "QUESTION: 什么是动产抵押融资的产品类型和适用场景？融资主体是谁？融资额度和期限是多少？融资成本是多少？担保方式有哪些？\nANSWER: 动产抵押融资的产品类型是动产融资，适用场景是中小企业。融资主体是中小企业，融资额度为50万元以上，融资期限为1个月至3年，融资成本为5%-8%。担保方式包括动产抵押、信用担保、保证担保等。",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "completion_tokens": 181,
      "prompt_tokens": 367,
      "total_tokens": 548
    },
    "model_name": "gpt-3.5-turbo",
    "system_fingerprint": "fp_4f0b692a78"
  },
  "run": null
}
[llm/end] [1:chain:ZhCNQAGenerateChain > 6:llm:ChatOpenAI] [17.98s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "QUESTION: 保单融资产品的适用场景是什么？融资主体是谁？融资额度和期限分别是多少？\nANSWER: 保单融资产品适用于核心企业和中小企业，融资主体也是核心企业和中小企业。融资额度为100万元以上，融资期限为1个月至1年。",
        "generation_info": {
          "finish_reason": "stop",
          "logprobs": null
        },
        "type": "ChatGeneration",
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "QUESTION: 保单融资产品的适用场景是什么？融资主体是谁？融资额度和期限分别是多少？\nANSWER: 保单融资产品适用于核心企业和中小企业，融资主体也是核心企业和中小企业。融资额度为100万元以上，融资期限为1个月至1年。",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "completion_tokens": 114,
      "prompt_tokens": 364,
      "total_tokens": 478
    },
    "model_name": "gpt-3.5-turbo",
    "system_fingerprint": "fp_4f0b692a78"
  },
  "run": null
}
[llm/end] [1:chain:ZhCNQAGenerateChain > 7:llm:ChatOpenAI] [17.98s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "QUESTION: 什么是流水贷款的产品类型和适用场景？\nANSWER: 流水贷款的产品类型是信用融资，适用场景是核心企业和中小企业。",
        "generation_info": {
          "finish_reason": "stop",
          "logprobs": null
        },
        "type": "ChatGeneration",
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "QUESTION: 什么是流水贷款的产品类型和适用场景？\nANSWER: 流水贷款的产品类型是信用融资，适用场景是核心企业和中小企业。",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "completion_tokens": 58,
      "prompt_tokens": 344,
      "total_tokens": 402
    },
    "model_name": "gpt-3.5-turbo",
    "system_fingerprint": "fp_4f0b692a78"
  },
  "run": null
}
[chain/end] [1:chain:ZhCNQAGenerateChain] [18.01s] Exiting Chain run with output:
{
  "outputs": [
    {
      "qa_pairs": {
        "query": "什么是\"应收账款质押融资\"的产品类型？融资主体是谁？融资额度和期限是多少？融资成本是多少？担保方式有哪些？",
        "answer": "\"应收账款质押融资\"的产品类型是动产融资。融资主体可以是核心企业或中小企业。融资额度为100万元以上，融资期限为1个月至3年，融资成本为5%-8%。担保方式包括应收账款质押、信用担保、保证担保等。"
      }
    },
    {
      "qa_pairs": {
        "query": "仓单融资产品的适用场景是什么？融资主体是谁？融资额度和期限分别是多少？融资成本是多少？担保方式有哪些？",
        "answer": "仓单融资产品适用于核心企业和中小企业。融资主体也是核心企业和中小企业。融资额度为100万元以上，融资期限为1个月至3年。融资成本为4%-7%。担保方式包括仓单质押、信用担保、保证担保等。"
      }
    },
    {
      "qa_pairs": {
        "query": "产品名称为什么是订单融资？产品类型是什么？产品简介是什么？",
        "answer": "产品名称是订单融资，因为该产品是以订单为基础获取融资。产品类型是信用融资。产品简介是以订单为基础获取融资。"
      }
    },
    {
      "qa_pairs": {
        "query": "什么是动产抵押融资的产品类型和适用场景？融资主体是谁？融资额度和期限是多少？融资成本是多少？担保方式有哪些？",
        "answer": "动产抵押融资的产品类型是动产融资，适用场景是中小企业。融资主体是中小企业，融资额度为50万元以上，融资期限为1个月至3年，融资成本为5%-8%。担保方式包括动产抵押、信用担保、保证担保等。"
      }
    },
    {
      "qa_pairs": {
        "query": "保单融资产品的适用场景是什么？融资主体是谁？融资额度和期限分别是多少？",
        "answer": "保单融资产品适用于核心企业和中小企业，融资主体也是核心企业和中小企业。融资额度为100万元以上，融资期限为1个月至1年。"
      }
    },
    {
      "qa_pairs": {
        "query": "什么是流水贷款的产品类型和适用场景？",
        "answer": "流水贷款的产品类型是信用融资，适用场景是核心企业和中小企业。"
      }
    }
  ]
}
[chain/start] [1:chain:RetrievalQA] Entering Chain run with input:
{
  "query": "仓单融资的产品的优点是什么?"
}
[chain/start] [1:chain:RetrievalQA > 3:chain:StuffDocumentsChain] Entering Chain run with input:
[inputs]
[chain/start] [1:chain:RetrievalQA > 3:chain:StuffDocumentsChain > 4:chain:LLMChain] Entering Chain run with input:
{
  "question": "仓单融资的产品的优点是什么?",
  "context": "产品名称: 仓单融资\n产品类型: 动产融资\n产品简介: 以仓单为质押品获取融资\n适用场景: 核心企业、中小企业\n融资主体: 核心企业、中小企业\n融资额度: 100万元以上\n融资期限: 1个月-3年\n融资成本: 4%-7%\n担保方式: 仓单质押、信用担保、保证担保等\n风险控制: 货物真实性、权属清晰性、仓储安全等\n优势: 融资便捷、成本较低、盘活存货资产\n案例: 某贸易企业利用仓单融资，获得了500万元的流动资金，用于扩大进出口业务，提高了资金周转效率。\n\n产品名称: 订单融资\n产品类型: 信用融资\n产品简介: 以订单为基础获取融资\n适用场景: 核心企业、中小企业\n融资主体: 核心企业、中小企业\n融资额度: 100万元以上\n融资期限: 1个月-1年\n融资成本: 3%-6%\n担保方式: 订单真实性、买方信用状况等\n风险控制: 订单池管理、风险分散等\n优势: 融资便捷、成本较低、提升供应链协同效率\n案例: 某电商企业利用订单融资，获得了2000万元的流动资金，用于备货发货，满足了订单快速增长的需求。\n\n产品名称: 保单融资\n产品类型: 信用融资\n产品简介: 以保单为质押品获取融资\n适用场景: 核心企业、中小企业\n融资主体: 核心企业、中小企业\n融资额度: 100万元以上\n融资期限: 1个月-1年\n融资成本: 3%-6%\n担保方式: 保单质押、信用担保、保证担保等\n风险控制: 保单真实性、保费支付记录等\n优势: 融资便捷、成本较低、盘活保单资产\n案例: 某制造企业利用保单融资，获得了500万元的流动资金，用于采购原材料，降低了融资成本。\n\n产品名称: 动产抵押融资\n产品类型: 动产融资\n产品简介: 以动产（如设备、车辆等）为质押品获取融资\n适用场景: 中小企业\n融资主体: 中小企业\n融资额度: 50万元以上\n融资期限: 1个月-3年\n融资成本: 5%-8%\n担保方式: 动产抵押、信用担保、保证担保等\n风险控制: 动产权属清晰性、评估价值等\n优势: 融资便捷、提高资产利用率\n案例: 某科技企业利用动产抵押融资，获得了100万元的流动资金，用于研发新产品，提升了企业竞争力。"
}
[llm/start] [1:chain:RetrievalQA > 3:chain:StuffDocumentsChain > 4:chain:LLMChain > 5:llm:ChatOpenAI] Entering LLM run with input:
{
  "prompts": [
    "System: Use the following pieces of context to answer the user's question. \nIf you don't know the answer, just say that you don't know, don't try to make up an answer.\n----------------\n产品名称: 仓单融资\n产品类型: 动产融资\n产品简介: 以仓单为质押品获取融资\n适用场景: 核心企业、中小企业\n融资主体: 核心企业、中小企业\n融资额度: 100万元以上\n融资期限: 1个月-3年\n融资成本: 4%-7%\n担保方式: 仓单质押、信用担保、保证担保等\n风险控制: 货物真实性、权属清晰性、仓储安全等\n优势: 融资便捷、成本较低、盘活存货资产\n案例: 某贸易企业利用仓单融资，获得了500万元的流动资金，用于扩大进出口业务，提高了资金周转效率。\n\n产品名称: 订单融资\n产品类型: 信用融资\n产品简介: 以订单为基础获取融资\n适用场景: 核心企业、中小企业\n融资主体: 核心企业、中小企业\n融资额度: 100万元以上\n融资期限: 1个月-1年\n融资成本: 3%-6%\n担保方式: 订单真实性、买方信用状况等\n风险控制: 订单池管理、风险分散等\n优势: 融资便捷、成本较低、提升供应链协同效率\n案例: 某电商企业利用订单融资，获得了2000万元的流动资金，用于备货发货，满足了订单快速增长的需求。\n\n产品名称: 保单融资\n产品类型: 信用融资\n产品简介: 以保单为质押品获取融资\n适用场景: 核心企业、中小企业\n融资主体: 核心企业、中小企业\n融资额度: 100万元以上\n融资期限: 1个月-1年\n融资成本: 3%-6%\n担保方式: 保单质押、信用担保、保证担保等\n风险控制: 保单真实性、保费支付记录等\n优势: 融资便捷、成本较低、盘活保单资产\n案例: 某制造企业利用保单融资，获得了500万元的流动资金，用于采购原材料，降低了融资成本。\n\n产品名称: 动产抵押融资\n产品类型: 动产融资\n产品简介: 以动产（如设备、车辆等）为质押品获取融资\n适用场景: 中小企业\n融资主体: 中小企业\n融资额度: 50万元以上\n融资期限: 1个月-3年\n融资成本: 5%-8%\n担保方式: 动产抵押、信用担保、保证担保等\n风险控制: 动产权属清晰性、评估价值等\n优势: 融资便捷、提高资产利用率\n案例: 某科技企业利用动产抵押融资，获得了100万元的流动资金，用于研发新产品，提升了企业竞争力。\nHuman: 仓单融资的产品的优点是什么?"
  ]
}
[llm/end] [1:chain:RetrievalQA > 3:chain:StuffDocumentsChain > 4:chain:LLMChain > 5:llm:ChatOpenAI] [1.78s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "仓单融资的产品优点包括融资便捷、成本较低、以及盘活存货资产。",
        "generation_info": {
          "finish_reason": "stop",
          "logprobs": null
        },
        "type": "ChatGeneration",
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "仓单融资的产品优点包括融资便捷、成本较低、以及盘活存货资产。",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "completion_tokens": 40,
      "prompt_tokens": 1065,
      "total_tokens": 1105
    },
    "model_name": "gpt-3.5-turbo",
    "system_fingerprint": "fp_4f0b692a78"
  },
  "run": null
}
[chain/end] [1:chain:RetrievalQA > 3:chain:StuffDocumentsChain > 4:chain:LLMChain] [1.78s] Exiting Chain run with output:
{
  "text": "仓单融资的产品优点包括融资便捷、成本较低、以及盘活存货资产。"
}
[chain/end] [1:chain:RetrievalQA > 3:chain:StuffDocumentsChain] [1.80s] Exiting Chain run with output:
{
  "output_text": "仓单融资的产品优点包括融资便捷、成本较低、以及盘活存货资产。"
}
[chain/end] [1:chain:RetrievalQA] [2.90s] Exiting Chain run with output:
{
  "result": "仓单融资的产品优点包括融资便捷、成本较低、以及盘活存货资产。"
}
{'query': '仓单融资的产品的优点是什么?', 'result': '仓单融资的产品优点包括融资便捷、成本较低、以及盘活存货资产。'}

# flake8: noqa
from langchain.globals import set_debug
from langchain_openai.chat_models import ChatOpenAI
from langchain_community.llms.ollama import Ollama
from langchain_community.document_loaders.csv_loader import CSVLoader
from langchain_community.vectorstores.docarray import DocArrayInMemorySearch
from langchain_openai import OpenAIEmbeddings
from langchain.indexes import VectorstoreIndexCreator
from langchain.chains import RetrievalQA
from langchain.evaluation.qa import QAGenerateChain, QAEvalChain
from langchain.base_language import BaseLanguageModel
from langchain.prompts import PromptTemplate
from typing import Any

from pydantic import SecretStr

api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"
ollama_url = "http://127.0.0.1:11434"


template = """You are a teacher coming up with questions to ask on a quiz.
Given the following document, please generate a question and answer based on that document.

Example Format:
<Begin Document>
...
<End Document>
QUESTION: question here
ANSWER: answer here

These questions should be detailed and be based explicitly on information in the document. Begin!

<Begin Document>
{doc}
<End Document>
请使用中文输出
"""
PROMPT = PromptTemplate(
    input_variables=["doc"],
    template=template,
)

# 继承QAGenerateChain，重写from_llm方法
class ZhCNQAGenerateChain(QAGenerateChain):
    """LLM Chain for generating examples for question answering."""

    @classmethod
    def from_llm(cls, llm: BaseLanguageModel, **kwargs: Any) -> QAGenerateChain:
        """Load QA Generate Chain from LLM."""
        return cls(llm=llm, prompt=PROMPT, **kwargs)


def main():
    # 关闭LangChain全局debug
    set_debug(False)

    # 1.使用LangChain文档加载器csv类型对数据进行导入
    file = "/Users/iceyao/Desktop/test_101.csv"
    csv_loader = CSVLoader(file_path=file)
    docs = csv_loader.load()

    # 2.基于文档加载器创建LangChain向量存储索引，这里使用向量内存存储
    index = VectorstoreIndexCreator(
        vectorstore_cls=DocArrayInMemorySearch,
        embedding=OpenAIEmbeddings(
            api_key=api_key,
            base_url=openai_url)).from_loaders([csv_loader])

    # 3.声明OpenAI语言模型，用于自动生成LLM问答用例
    openai_llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    # 4.声明ollama模型(实际是llama2:13b)，用于评估问答答案
    ollama_llm = Ollama(base_url=ollama_url,
                        temperature=0,
                        model="qwen:7b"
                        )

    # 5.声明检索QA链
    retrieval_qa_chain = RetrievalQA.from_chain_type(
        llm=openai_llm,
        retriever=index.vectorstore.as_retriever(),
        chain_type="stuff",
        verbose=True,
    )

    # 6.声明ZhCNQAGenerateChain链，基于QA生成链
    qa_generate_chain = ZhCNQAGenerateChain.from_llm(openai_llm)

    # 7.ZhCNQAGenerateChain链调用apply方法自动创建问答对
    llm_examples = qa_generate_chain.apply([{"doc": t} for t in docs])

    examples = [v for item in llm_examples for _, v in item.items()]

    # 8.检索QA链为测试用例生成预测
    predictions = retrieval_qa_chain.batch(examples) # type: ignore[misc]

    # 9.声明QA评估链
    qa_eval_chain = QAEvalChain.from_llm(ollama_llm)

    # 10.QA评估链对其进行评估
    evaluate_results = qa_eval_chain.evaluate(examples, predictions) # type: ignore[misc]

    for i, _ in enumerate(examples):
        print(f"Example {i}:")
        print("Question: " + predictions[i]['query'])
        print("Real Answer: " + predictions[i]['answer'])
        print("Predicted Answer: " + predictions[i]['result'])
        print("Predicted Grade: " + evaluate_results[i]['results'])
        print()


if __name__ == "__main__":
    main()

> Entering new RetrievalQA chain...


> Entering new RetrievalQA chain...


> Entering new RetrievalQA chain...


> Entering new RetrievalQA chain...


> Entering new RetrievalQA chain...


> Entering new RetrievalQA chain...

> Finished chain.

> Finished chain.

> Finished chain.

> Finished chain.

> Finished chain.

> Finished chain.
Example 0:
Question: 什么是“应收账款质押融资”产品的主要特点和优势？请列举至少三点。
Real Answer: 该产品的主要特点和优势包括：以应收账款为质押品获取融资、适用于核心企业和中小企业、融资额度在100万元以上、融资期限为1个月至3年、融资成本在5%-8%之间、担保方式包括应收账款质押、信用担保、保证担保等、风险控制主要关注应收账款真实性、债权清晰性、履约能力等、优势在于融资便捷、成本较低、提高资金利用率。
Predicted Answer: “应收账款质押融资”产品的主要特点和优势包括：

1. **融资便捷**：通过将应收账款作为质押品，企业可以相对容易地获取融资，无需进行繁琐的审批流程，提高了融资的速度和效率。

2. **成本较低**：相比其他融资方式，应收账款质押融资的成本通常在5%-8%之间，相对较低，有助于降低企业的融资成本，提升盈利能力。

3. **提高资金利用率**：通过将应收账款作为质押品获得融资，企业可以有效地利用未来的收款权益，提前获取资金用于业务发展，提高了资金的利用效率和灵活性。
Predicted Grade: CORRECT


Example 1:
Question: 仓单融资产品的适用场景是什么？融资主体是谁？融资额度和期限分别是多少？融资成本是多少？担保方式有哪些？
Real Answer: 仓单融资产品适用于核心企业和中小企业。融资主体也是核心企业和中小企业。融资额度为100万元以上，融资期限为1个月至3年。融资成本为4%-7%。担保方式包括仓单质押、信用担保、保证担保等。
Predicted Answer: 仓单融资产品的适用场景是核心企业和中小企业。融资主体也是核心企业和中小企业。融资额度是100万元以上，融资期限为1个月到3年。融资成本为4%-7%。担保方式包括仓单质押、信用担保、保证担保等。
Predicted Grade: CORRECT


Example 2:
Question: 什么是订单融资的产品简介和适用场景？融资额度和期限是多少？融资成本是多少？担保方式和风险控制措施是什么？
Real Answer: 订单融资是以订单为基础获取融资的信用融资产品，适用于核心企业和中小企业。融资额度为100万元以上，融资期限为1个月至1年，融资成本为3%-6%。担保方式包括订单真实性和买方信用状况等，风险控制措施包括订单池管理和风险分散。
Predicted Answer: 订单融资的产品简介是以订单为基础获取融资，适用场景是核心企业和中小企业。融资额度是100万元以上，融资期限为1个月到1年，融资成本为3%-6%。担保方式包括订单真实性和买方信用状况等，风险控制措施包括订单池管理和风险分散等。
Predicted Grade: CORRECT


Example 3:
Question: 什么是动产抵押融资的产品简介？ 
Real Answer: 以动产（如设备、车辆等）为质押品获取融资
Predicted Answer: 动产抵押融资的产品简介是以动产（如设备、车辆等）作为质押品来获取融资。
Predicted Grade: CORRECT


Example 4:
Question: 保单融资产品的适用场景是什么？融资主体是谁？融资额度和期限分别是多少？融资成本是多少？担保方式有哪些？
Real Answer: 保单融资产品适用于核心企业和中小企业，融资主体也是核心企业和中小企业。融资额度为100万元以上，融资期限为1个月至1年，融资成本为3%-6%。担保方式包括保单质押、信用担保、保证担保等。
Predicted Answer: 保单融资产品的适用场景是核心企业和中小企业。融资主体是核心企业和中小企业。融资额度是100万元以上，融资期限是1个月到1年。融资成本是3%-6%。担保方式包括保单质押、信用担保、保证担保等。
Predicted Grade: CORRECT


Example 5:
Question: 请问流水贷款的产品类型是什么？
Real Answer: 信用融资
Predicted Answer: 流水贷款的产品类型是信用融资。
Predicted Grade: CORRECT

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent, load_tools
from pydantic import SecretStr
from langchain import hub

api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


def main():
    # 初始化一个基础的LLM
    llm = ChatOpenAI(
        temperature=0.0,
        base_url=openai_url,
        api_key=api_key,
        streaming=True,
        verbose=True,
    )

    # 初始化工具，这里用到两个内置工具
    # llm-math: 工具结合语言模型和计算器用以进行数学计算
    # wikipedia: 工具通过API连接到wikipedia进行搜索查询
    tools = load_tools(tool_names=["llm-math", "wikipedia"], llm=llm)

    # 从hub上拉取prompt模版
    prompt = hub.pull("hwchase17/openai-tools-agent")

    # 初始化agent
    agent = create_openai_tools_agent(llm, tools, prompt)

    # 运行agent
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True)

    agent_executor.invoke({"input": "计算300的25%"})
    agent_executor.invoke({"input": "曹德旺做了哪些善事"})


if __name__ == "__main__":
    main()

> Entering new AgentExecutor chain...

Invoking: `Calculator` with `300*0.25`


Answer: 75.025% of 300 is 75.

> Finished chain.


> Entering new AgentExecutor chain...

Invoking: `wikipedia` with `曹德旺`


Page: Cao Dewang
Summary: Cao Dewang (Chinese: 曹德旺; pinyin: Cáo Déwàng; born May 1946), also known as Cho Tak Wong or Tak Wong Cho, is a Chinese entrepreneur. He is the chairman of Fuyao Group, one of the largest glass manufacturers in the world. He is also a member of the Chinese People's Consultative Conference from Fujian, and chairman of both the China Automobile Glass Association and the Fujian Golf Players' Association.

Page: Jack Wong
Summary: Jack Wong, or Huang Zhang (Chinese: 黄章; pinyin: Huáng Zhāng), is a Chinese billionaire entrepreneur. He is the founder and chairman of Meizu, a Chinese consumer electronics company.

Page: Crocodile Island (film)
Summary: Crocodile Island is a 2020 Chinese action monster film directed by Xu Shixing and Simon Zhao, and starring Gallen Lo as a single father who lands on a crocodile island with his daughter (Liao Yinyue) due to a plane malfunction and must battle with beast-sized creatures inhabiting the island. This web film was released for online streaming on 4 February 2020 on iQiyi. Crocodile Island became a commercial success, grossing ¥16.70 million against a budget of ¥8 million and is currently the highest-grossing web film of 2020 in China.根据维基百科，曹德旺是中国企业家，福耀集团董事长，也是中国汽车玻璃协会和福建高尔夫球员协会的主席。关于他做了哪些善事的具体信息可能需要更深入的研究。您是否希望我帮助您进一步了解曹德旺的善举？

> Finished chain.

from langchain_openai import ChatOpenAI
from langchain_experimental.agents.agent_toolkits.python.base import create_python_agent
from langchain_experimental.tools import PythonREPLTool
from pydantic import SecretStr

api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


def main():
    llm = ChatOpenAI(
        temperature=0.0,
        base_url=openai_url,
        api_key=api_key,
        streaming=True,
        verbose=True,
    )

    tool = PythonREPLTool()

    agent = create_python_agent(
        llm, tool, verbose=True)

    customer_list = ["张三", "李四", "王五"]

    agent.invoke(
        {"input": f"使用pinyin拼音库这些客户名字转换为拼音，并打印输出列表: {customer_list}。"})


if __name__ == "__main__":
    main()

> Entering new AgentExecutor chain...
I need to use the pinyin library to convert the names to pinyin.
Action: Python_REPL
Action Input: 
```python
from pypinyin import pinyin
names = ['张三', '李四', '王五']
pinyin_names = ["".join([y[0] for y in x]) for x in [pinyin(name, style=0) for name in names]]
print(pinyin_names)
```Python REPL can execute arbitrary code. Use with caution.

Observation: ['zhangsan', 'lisi', 'wangwu']

Thought:The names have been successfully converted to pinyin.
Final Answer: ['zhangsan', 'lisi', 'wangwu']

> Finished chain.

from langchain.agents import tool
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from pydantic import SecretStr
from datetime import date
from langchain import hub

api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


@tool
def time(text: str) -> str:
    """
    """
    return str(date.today())


def main():
    llm = ChatOpenAI(
        temperature=0.0,
        base_url=openai_url,
        api_key=api_key,
        streaming=True,
        verbose=True,
    )

    tools = [time]

    # 从hub上拉取prompt模版
    prompt = hub.pull("hwchase17/openai-tools-agent")

    # 初始化agent
    agent = create_openai_tools_agent(llm, tools, prompt)

    # 运行agent
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True)

    agent_executor.invoke({"input": "今天的日期是多少"})


if __name__ == "__main__":
    main()

> Entering new AgentExecutor chain...

Invoking: `time` with `{'text': 'today'}`


2024-03-27今天是2024年3月27日。

> Finished chain.

# pip install --upgrade --quiet  langchain langchain-community langchainhub langchain-openai langchain-chroma bs4

import bs4
from langchain import hub
from langchain_community.document_loaders.web_base import WebBaseLoader
from langchain_chroma import Chroma
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import ChatOpenAI
from pydantic.v1 import SecretStr

api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


def main():

    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    # Load, chunk and index the contents of the blog.
    loader = WebBaseLoader(
        web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
        bs_kwargs=dict(
            parse_only=bs4.SoupStrainer(
                class_=("post-content", "post-title", "post-header")
            )
        ),
    )
    docs = loader.load()

    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000, chunk_overlap=200)
    splits = text_splitter.split_documents(docs)
    vectorstore = Chroma.from_documents(
        documents=splits, embedding=OpenAIEmbeddings(
            api_key=api_key,
            base_url=openai_url
        ))

    # Retrieve and generate using the relevant snippets of the blog.
    retriever = vectorstore.as_retriever()
    prompt = hub.pull("rlm/rag-prompt")

    def format_docs(docs):
        return "\n\n".join(doc.page_content for doc in docs)

    rag_chain = (
        {"context": retriever | format_docs, "question": RunnablePassthrough()}
        | prompt
        | llm
        | StrOutputParser()
    )

    print(rag_chain.invoke("What is Task Decomposition?"))
    vectorstore.delete_collection()


if __name__ == "__main__":
    main()

Task Decomposition is a technique used to break down complex tasks into smaller and simpler steps. This process helps agents or models better understand and tackle the task at hand by dividing it into manageable parts. It can be implemented through prompting techniques like Chain of Thought or Tree of Thoughts, task-specific instructions, or human inputs.

from langchain_openai import ChatOpenAI
from pydantic.v1 import SecretStr
from typing import List, Optional

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field


api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


class Person(BaseModel):
    """Information about a person."""

    # ^ Doc-string for the entity Person.
    # This doc-string is sent to the LLM as the description of the schema Person,
    # and it can help to improve extraction results.

    # Note that:
    # 1. Each field is an `optional` -- this allows the model to decline to extract it!
    # 2. Each field has a `description` -- this description is used by the LLM.
    # Having a good description can help improve extraction results.
    name: Optional[str] = Field(default=None, description="The name of the person")
    hair_color: Optional[str] = Field(
        default=None, description="The color of the peron's hair if known"
    )
    height_in_meters: Optional[str] = Field(
        default=None, description="Height measured in meters"
    )


class Data(BaseModel):
    """Extracted data about people."""

    # Creates a model so that we can extract multiple entities.
    people: List[Person]


def main():

    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    # Define a custom prompt to provide instructions and any additional context.
# 1) You can add examples into the prompt template to improve extraction quality
# 2) Introduce additional parameters to take context into account (e.g., include metadata
#    about the document from which the text was extracted.)
    prompt = ChatPromptTemplate.from_messages(
        [
            (
                "system",
                "You are an expert extraction algorithm. "
                "Only extract relevant information from the text. "
                "If you do not know the value of an attribute asked to extract, "
                "return null for the attribute's value.",
            ),
            # Please see the how-to about improving performance with
            # reference examples.
            # MessagesPlaceholder('examples'),
            ("human", "{text}"),
        ]
    )

    runnable = prompt | llm.with_structured_output(schema=Data)
    text = "My name is Jeff, my hair is black and i am 6 feet tall. Anna has the same color hair as me."
    print(runnable.invoke({"text": text}))


if __name__ == "__main__":
    main()

people=[Person(name='Jeff', hair_color='black', height_in_meters='1.83'), Person(name='Anna', hair_color='black', height_in_meters=None)]

from langchain_openai import ChatOpenAI
from pydantic.v1 import SecretStr

from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableBranch
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.document_loaders.web_base import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.runnables import RunnablePassthrough
from langchain.memory import ChatMessageHistory


api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


def main():

    chat = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    loader = WebBaseLoader("https://docs.smith.langchain.com/overview")
    data = loader.load()

    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500, chunk_overlap=0)
    all_splits = text_splitter.split_documents(data)
    vectorstore = Chroma.from_documents(documents=all_splits, embedding=OpenAIEmbeddings(
        api_key=api_key, base_url=openai_url))
    retriever = vectorstore.as_retriever(k=4)

    query_transform_prompt = ChatPromptTemplate.from_messages(
        [
            MessagesPlaceholder(variable_name="messages"),
            (
                "user",
                "Given the above conversation, generate a search query to look up in order to get information relevant to the conversation. Only respond with the query, nothing else.",
            ),
        ]
    )

    question_answering_prompt = ChatPromptTemplate.from_messages(
        [
            (
                "system",
                "Answer the user's questions based on the below context:\n\n{context}",
            ),
            MessagesPlaceholder(variable_name="messages"),
        ]
    )

    query_transforming_retriever_chain = RunnableBranch(
        (
            lambda x: len(x.get("messages", [])) == 1,
            # If only one message, then we just pass that message's content to retriever
            (lambda x: x["messages"][-1].content) | retriever,
        ),
        # If messages, then we pass inputs to LLM chain to transform the query, then pass to retriever
        query_transform_prompt | chat | StrOutputParser() | retriever,
    ).with_config(run_name="chat_retriever_chain")
    document_chain = create_stuff_documents_chain(
        chat, question_answering_prompt)

    conversational_retrieval_chain = RunnablePassthrough.assign(
        context=query_transforming_retriever_chain,
    ).assign(
        answer=document_chain,
    )

    demo_ephemeral_chat_history = ChatMessageHistory()
    demo_ephemeral_chat_history.add_user_message(
        "how can langsmith help with testing?")

    response = conversational_retrieval_chain.invoke(
        {"messages": demo_ephemeral_chat_history.messages},
    )

    demo_ephemeral_chat_history.add_ai_message(response["answer"])
    demo_ephemeral_chat_history.add_user_message("tell me more about that!")

    print(conversational_retrieval_chain.invoke(
        {"messages": demo_ephemeral_chat_history.messages}
    ))


if __name__ == "__main__":
    main()

{'messages': [HumanMessage(content='how can langsmith help with testing?'), AIMessage(content="LangSmith is designed to aid in the development and testing of production-grade large language model (LLM) applications. Here's how it can help with testing:\n\n1. **Monitoring and Evaluation**: LangSmith allows you to closely monitor and evaluate your LLM application during testing. This means you can track its performance, identify any issues or bottlenecks, and make necessary improvements before deployment.\n\n2. **Tracing Capabilities**: With LangSmith, you can utilize its tracing capabilities to trace the execution of your LLM application. This helps in understanding how the application behaves under different inputs and scenarios, which is crucial for testing and debugging.\n\n3. **Prompt Hub**: LangSmith includes a Prompt Hub, which is a prompt management tool. This can be useful during testing as it helps in managing and organizing prompts for your LLM application, making it easier to iterate and test different inputs.\n\n4. **Proxy**: LangSmith offers proxy capabilities, which can be utilized to control and manage access to your LLM application during testing. This ensures that only authorized users or systems can interact with the application, enhancing security and control during testing phases.\n\n5. **Cookbook and Additional Resources**: LangSmith provides a Cookbook, which is a collection of tutorials and walkthroughs. These resources can guide you through the testing process, providing best practices and tips for testing LLM applications effectively.\n\nOverall, LangSmith offers a comprehensive set of tools and capabilities to support testing of LLM applications, enabling developers to ship quickly and with confidence."), HumanMessage(content='tell me more about that!')], 'context': [Document(page_content='Skip to main contentLangSmith API DocsSearchGo to AppQuick StartUser GuideTracingEvaluationProduction Monitoring & AutomationsPrompt HubProxyPricingSelf-HostingCookbookQuick StartOn this pageGetting started with LangSmithIntroduction\u200bLangSmith is a platform for building production-grade LLM applications. It allows you to closely monitor and evaluate your application, so you can ship quickly and with confidence. Use of LangChain is not necessary - LangSmith works on its own!Install LangSmith\u200bWe', metadata={'description': 'Introduction', 'language': 'en', 'source': 'https://docs.smith.langchain.com/overview', 'title': 'Getting started with LangSmith | 🦜️🛠️ LangSmith'}), Document(page_content='LangSmith.Self-Hosting: Learn about self-hosting options for LangSmith.Proxy: Learn about the proxy capabilities of LangSmith.Tracing: Learn about the tracing capabilities of LangSmith.Evaluation: Learn about the evaluation capabilities of LangSmith.Prompt Hub Learn about the Prompt Hub, a prompt management tool built into LangSmith.Additional Resources\u200bLangSmith Cookbook: A collection of tutorials and end-to-end walkthroughs using LangSmith.LangChain Python: Docs for the Python LangChain', metadata={'description': 'Introduction', 'language': 'en', 'source': 'https://docs.smith.langchain.com/overview', 'title': 'Getting started with LangSmith | 🦜️🛠️ LangSmith'}), Document(page_content='Getting started with LangSmith | 🦜️🛠️ LangSmith', metadata={'description': 'Introduction', 'language': 'en', 'source': 'https://docs.smith.langchain.com/overview', 'title': 'Getting started with LangSmith | 🦜️🛠️ LangSmith'}), Document(page_content='goes here    datasetName, // The data to predict and grade over    {        evaluationConfig: { customEvaluators: [exactMatch] },        projectMetadata: {            version: "1.0.0",            revision_id: "beta",        },    });See more on the evaluation quick start page.Next Steps\u200bCheck out the following sections to learn more about LangSmith:User Guide: Learn about the workflows LangSmith supports at each stage of the LLM application lifecycle.Pricing: Learn about the pricing model for', metadata={'description': 'Introduction', 'language': 'en', 'source': 'https://docs.smith.langchain.com/overview', 'title': 'Getting started with LangSmith | 🦜️🛠️ LangSmith'})], 'answer': "Sure, let's dive deeper into each aspect of how LangSmith can help with testing:\n\n1. **Monitoring and Evaluation**: LangSmith allows you to monitor various metrics and evaluate the performance of your LLM application during testing. This includes tracking metrics such as accuracy, response time, resource utilization, and more. By closely monitoring these metrics, you can identify any issues or areas for improvement in your application's performance.\n\n2. **Tracing Capabilities**: Tracing capabilities in LangSmith enable you to trace the execution flow of your LLM application. This means you can track how the application processes input prompts, generates responses, and executes various tasks. Tracing helps in understanding the behavior of the application under different conditions, which is essential for thorough testing and debugging.\n\n3. **Prompt Hub**: The Prompt Hub is a built-in tool in LangSmith for managing prompts used in your LLM application. During testing, you can use the Prompt Hub to organize and manage different test cases and input prompts. This makes it easier to iterate on testing scenarios, compare results, and refine your LLM model based on testing feedback.\n\n4. **Proxy**: LangSmith's proxy capabilities provide control and management over access to your LLM application. This is particularly useful during testing when you want to restrict access to the application to specific users or systems. By using the proxy features, you can ensure that testing environments are properly controlled and secured, reducing the risk of unauthorized access or misuse.\n\n5. **Cookbook and Additional Resources**: The LangSmith Cookbook and additional resources provide tutorials, walkthroughs, and best practices for testing LLM applications. These resources cover various aspects of testing, including setting up test environments, designing test cases, interpreting test results, and optimizing performance. By leveraging these resources, you can improve the effectiveness and efficiency of your testing processes.\n\nOverall, LangSmith offers a comprehensive suite of tools and resources to support testing of LLM applications at every stage of development. From monitoring and evaluation to tracing, prompt management, proxying, and access to helpful documentation, LangSmith empowers developers to conduct thorough testing and ensure the reliability and performance of their LLM applications before deployment."}

from langchain_openai import ChatOpenAI
from pydantic.v1 import SecretStr
from langchain_core.tools import tool


api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


@tool
def multiply(first_int: int, second_int: int) -> int:
    """Multiply two integers together."""
    return first_int * second_int


def main():

    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    llm_with_tools = llm.bind_tools([multiply])
    # 直接函数/工具调用
    msg = llm_with_tools.invoke("whats 5 times forty two")
    print(msg.tool_calls)

    # 链中调用工具
    chain = llm_with_tools | (lambda x: x.tool_calls[0]["args"]) | multiply
    print(chain.invoke("What's four times 23"))


if __name__ == "__main__":
    main()

[{'name': 'multiply', 'args': {'first_int': 5, 'second_int': 42}, 'id': 'call_tYHGZbXVcZo2KTHTF9PGTEW3'}]
92

from langchain_openai import ChatOpenAI
from pydantic.v1 import SecretStr
from langchain_core.tools import tool
from langchain import hub
from langchain.agents import AgentExecutor, create_tool_calling_agent


api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


@tool
def multiply(first_int: int, second_int: int) -> int:
    """Multiply two integers together."""
    return first_int * second_int


@tool
def add(first_int: int, second_int: int) -> int:
    "Add two integers."
    return first_int + second_int


@tool
def exponentiate(base: int, exponent: int) -> int:
    "Exponentiate the base to the exponent power."
    return base**exponent


def main():

    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    # Get the prompt to use - can be replaced with any prompt that includes variables "agent_scratchpad" and "input"!
    prompt = hub.pull("hwchase17/openai-tools-agent")

    tools = [multiply, add, exponentiate]
    # Construct the tool calling agent
    agent = create_tool_calling_agent(llm, tools, prompt)

    # Create an agent executor by passing in the agent and tools
    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
    agent_executor.invoke(
        {
            "input": "Take 3 to the fifth power and multiply that by the sum of twelve and three, then square the whole result"
        }
    )


if __name__ == "__main__":
    main()

> Entering new AgentExecutor chain...

Invoking: `exponentiate` with `{'base': 3, 'exponent': 5}`


243
Invoking: `add` with `{'first_int': 12, 'second_int': 3}`


15
Invoking: `multiply` with `{'first_int': 243, 'second_int': 15}`


3645
Invoking: `exponentiate` with `{'base': 3645, 'exponent': 2}`


13286025The result of taking 3 to the fifth power and multiplying that by the sum of twelve and three, then squaring the whole result is 13,286,025.

> Finished chain.

from langchain_community.document_loaders.youtube import YoutubeLoader
from langchain_openai import ChatOpenAI
from pydantic.v1 import SecretStr
import datetime
from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from typing import Optional
from langchain_core.pydantic_v1 import BaseModel, Field
from typing import List
from langchain_core.documents import Document


api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


class Search(BaseModel):
    """Search over a database of tutorial videos about a software library."""

    query: str = Field(
        ...,
        description="Similarity search query applied to video transcripts.",
    )
    publish_year: Optional[int] = Field(
        None, description="Year video was published")


def main():
    urls = [
        "https://www.youtube.com/watch?v=HAn9vnJy6S4",
        "https://www.youtube.com/watch?v=dA1cHGACXCo",
        "https://www.youtube.com/watch?v=ZcEMLz27sL4",
        "https://www.youtube.com/watch?v=hvAPnpSfSGo",
        "https://www.youtube.com/watch?v=EhlPDL4QrWY",
        "https://www.youtube.com/watch?v=mmBo8nlu2j0",
        "https://www.youtube.com/watch?v=rQdibOsL1ps",
        "https://www.youtube.com/watch?v=28lC4fqukoc",
        "https://www.youtube.com/watch?v=es-9MgxB-uc",
        "https://www.youtube.com/watch?v=wLRHwKuKvOE",
        "https://www.youtube.com/watch?v=ObIltMaRJvY",
        "https://www.youtube.com/watch?v=DjuXACWYkkU",
        "https://www.youtube.com/watch?v=o7C9ld6Ln-M",
    ]
    docs = []
    for url in urls:
        docs.extend(YoutubeLoader.from_youtube_url(
            url, add_video_info=True).load())

    # Add some additional metadata: what year the video was published
    for doc in docs:
        doc.metadata["publish_year"] = int(
            datetime.datetime.strptime(
                doc.metadata["publish_date"], "%Y-%m-%d %H:%M:%S"
            ).strftime("%Y")
        )

    text_splitter = RecursiveCharacterTextSplitter(chunk_size=2000)
    chunked_docs = text_splitter.split_documents(docs)
    embeddings = OpenAIEmbeddings(model="text-embedding-3-small",
                                  api_key=api_key,
                                  base_url=openai_url)

    vectorstore = Chroma.from_documents(
        chunked_docs,
        embeddings,
    )

    # retrivael without query analysis
    search_results = vectorstore.similarity_search(
        "how do I build a RAG agent")
    print(search_results[0].metadata["title"])
    print(search_results[0].page_content[:500])

    # query analysis
    system = """You are an expert at converting user questions into database queries. \
    You have access to a database of tutorial videos about a software library for building LLM-powered applications. \
    Given a question, return a list of database queries optimized to retrieve the most relevant results.

    If there are acronyms or words you are not familiar with, do not try to rephrase them."""
    prompt = ChatPromptTemplate.from_messages(
        [
            ("system", system),
            ("human", "{question}"),
        ]
    )
    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)
    structured_llm = llm.with_structured_output(Search)
    query_analyzer = {
        "question": RunnablePassthrough()} | prompt | structured_llm
    print(query_analyzer.invoke("how do I build a RAG agent"))

    def retrieval(search: Search) -> List[Document]:
        if search.publish_year is not None:
            # This is syntax specific to Chroma,
            # the vector database we are using.
            _filter = {"publish_year": {"$eq": search.publish_year}}
        else:
            _filter = None
        return vectorstore.similarity_search(search.query, filter=_filter)

    retrieval_chain = query_analyzer | retrieval
    results = retrieval_chain.invoke("RAG tutorial published in 2023")
    print(results)


if __name__ == "__main__":
    main()

OpenGPTs
hardcoded that it will always do a retrieval step here the assistant decides whether to do a retrieval step or not sometimes this is good sometimes this is bad sometimes it you don't need to do a retrieval step when I said hi it didn't need to call it tool um but other times you know the the llm might mess up and not realize that it needs to do a retrieval step and so the rag bot will always do a retrieval step so it's more focused there because this is also a simpler architecture so it's always
/opt/anaconda3/envs/chatgpt/lib/python3.11/site-packages/langchain_core/_api/beta_decorator.py:87: LangChainBetaWarning: The function `with_structured_output` is in beta. It is actively being worked on, so the API may change.
  warn_beta(
query='build RAG agent' publish_year=None
[Document(page_content="capacity and conventional rag approaches that just strip the text out really miss a lot of this so let's try kind of how could we build a rag system over the visual content in in a slide deck um so to start off what I did was I took a slide deck and this is um uh data dog's Q3 earnings report I randomly chose it you know it was just like an interesting demonstration of like kind of complex uh you know financial information and figures and slide deck and I created a set of 10 questions and answer pairs about these slides this is like my evalve set um and this is really easy to do I can just create a CSV that has like my question and my answer in this case like my input output pairs um and it's just a set of questions that I devised myself I looked at the slides I said okay here's some interesting question answer pairs I put them in a CSV and I load these into Langs Smith now Langs Smith is Lang chain platform that supports durability and evaluations um and I create a data set for myself in Lang Smith and there's some links down here that show exactly how to do that but that's my starting point so I say okay here's my evaluation set I have the slide deck I built 10 question answer pairs from the slides now let's compare some approaches there might be two different ways to think about multimodal rag um so one is this notion of multimodal embeddings so we take our slides we extract them as images in every image we use multimodal embeddings to map them into this kind of this embedding space that is common between kind of text and and images um for that I use open clip embeddings um and so I now have an index in this case I use chroma that contains a bunch of images uh that have been embedded using open clip um at retrieval time I ask a question I use I basically take the natural language question embed it indeed with multimodal embeddings same ones similarity search just like normal retrieve images that are similar to my question pass the image to in this case uh my", metadata={'author': 'LangChain', 'description': 'Unknown', 'length': 1833, 'publish_date': '2023-12-20 00:00:00', 'publish_year': 2023, 'source': '28lC4fqukoc', 'thumbnail_url': 'https://i.ytimg.com/vi/28lC4fqukoc/hq720.jpg?sqp=-oaymwEmCIAKENAF8quKqQMa8AEB-AH-CYAC0AWKAgwIABABGCkgWChyMA8=&rs=AOn4CLCPeU4y3IyyG2C3XDHmIYh8efhGbQ', 'title': 'Getting Started with Multi-Modal LLMs', 'view_count': 3766}), Document(page_content="uh context for it um instead of uh instead of asking a question so here we can just add our second route so now we're going to have um two different sets of endpoints um and I can actually just show that off in the uh fast API doc so if I refresh this we'll see now that we have all the invoke batch stream and stream log uh calls for rag conversation which was the first example that we went over or first template that we went over um and we also now have these extraction open AI functions ones um which just taken a single string instead of both like a chat history and a question and so if we go to our playground um so this is going to be our rag conversation playground um but we can go to extraction openingi functions um and we're adding a little index so it's easier to to get to these links um so in this case if we look at the readme for extraction open AI functions um what this is going to do is it's going to um extract the title and author of papers um which uh we'll look at in a sec and we'll we'll try and customize it to extract something else um but we can actually just use the same article over here um just because it also has paper ERS and authors um so if we just paste in some section of this um we can see that it's able not reminders um we can see that it's able to extract out um those authors and papers that are kind of covered in this Tas do composition section um and let's actually go into that template um to see why it's it's doing just papers um in instead um so here we can see that we have just a prompt going into a model uh which has kind of some open AI functions um set on it and then we'll talk a little bit how about how we can design those ourselves um and then in the end it's just going to Output that papers key um which is just going to be a list of papers according to our kind of pedantic model here um and then we can see that it's extracting title an author because we um Define those as as the fields to extract so let's say um I don't know", metadata={'author': 'LangChain', 'description': 'Unknown', 'length': 2441, 'publish_date': '2023-11-02 00:00:00', 'publish_year': 2023, 'source': 'o7C9ld6Ln-M', 'thumbnail_url': 'https://i.ytimg.com/vi/o7C9ld6Ln-M/hqdefault.jpg?sqp=-oaymwEXCJADEOABSFryq4qpAwkIARUAAIhCGAE=&rs=AOn4CLDf7gvV8D3I2UFy0UsA2Wh0qUhA-A', 'title': 'LangServe and LangChain Templates Webinar', 'view_count': 5000}), Document(page_content="and reason about what's going on so so that's maybe like a simple like mental model how to think about what's happening when you work with multimodal LMS um yeah let's talk a about use cases so Greg Cameron on Twitter kind of had this kind of nice visualization of a bunch of things that have been been shown with GPD 4V um a lot of people seen really cool demos with image captioning um extractions a really good one taking an image extracting elements text elements and so forth um recommendations so there's kind of like a lot of design applications um kind of suggestions about how to improve the visual Aesthetics of a scene of a of a of of like you know um of an object um and of course like interpretation this is like you know common in the rag context for example if you have like a you know collection of say we'll talk a little bit later to it a little bit later about slides um or about diagrams in documents you can of course use a vision model to reason about what's happening there in a question answer context um and this was like an intering demonstration of of extraction uh shown in the in the gbd uh 4V paper here uh actually this is a follow on to the GPD 4V model by Microsoft showing here are some interesting um explorations and they they talked about kind of extraction from complex documents um so let's actually walk through a demo to make this a little bit more concrete and I'll share kind of a bunch of code and and templates that can be easily reused later um so I think you know presentations like slide decks are a really good application for vision models because they're inherently kind of visual they have lots of kind of complex visual elements like like graphs uh tables figures and they're very common you know every nearly every organization uses slides in some capacity and conventional rag approaches that just strip the text out really miss a lot of this so let's try kind of how could we build a rag system over the visual content in in a slide deck um so", metadata={'author': 'LangChain', 'description': 'Unknown', 'length': 1833, 'publish_date': '2023-12-20 00:00:00', 'publish_year': 2023, 'source': '28lC4fqukoc', 'thumbnail_url': 'https://i.ytimg.com/vi/28lC4fqukoc/hq720.jpg?sqp=-oaymwEmCIAKENAF8quKqQMa8AEB-AH-CYAC0AWKAgwIABABGCkgWChyMA8=&rs=AOn4CLCPeU4y3IyyG2C3XDHmIYh8efhGbQ', 'title': 'Getting Started with Multi-Modal LLMs', 'view_count': 3766}), Document(page_content="this is the main thing I want to serve the thing that I copy has a bunch of extraneous things we can easily remove that um we can now do add routes app chain this is all useless stuff from before let's call This research assistant um and then we can do if we do this install SEC Starlet that's an easy fix no need to run that twice query run main install unicorn burun may now we can go here and we can add in research assistant playground and so now we get this thing what is the difference between L chain let's change it up what's the difference between L chain and open AI so this is a nice little this is all autogenerated we know that the input's question because we we know the internals of the chain that we wrote you can see the intermediate steps streams things automatically um Lang chain and open a are two prominent entities in the sphere each offering unique Frameworks and models so not exactly right we don't offer any models okay here we go open the eye provider of Link language models um Lang chain is a framework for language model applications cool so it gets those right general purpose versus chat focused um okay so it talks about the two different classes in Lang chain talks about our Integrations um developer platform um and conclusion and so we get a bunch of sources as well so that's pretty much it for this video um I'll post the code for this um in a in a simple gist or something um I'll also post uh the code for a more complex uh research assistant um oh let's maybe do one last thing let's maybe change this so instead of scraping the web it's using a different retriever of our choice and this is really interesting because uh you can now change it to do to do research over any corporate of data that you want so we'll change it we'll do some research over uh let's do some research over um over archive data all right so I've done some basic setup I've imported the archive retriever from L chain and I've got uh I've created the retriever class here what", metadata={'author': 'LangChain', 'description': 'Unknown', 'length': 2620, 'publish_date': '2023-11-16 00:00:00', 'publish_year': 2023, 'source': 'DjuXACWYkkU', 'thumbnail_url': 'https://i.ytimg.com/vi/DjuXACWYkkU/hq720.jpg', 'title': 'Building a Research Assistant from Scratch', 'view_count': 19059})]

# 下载Chinook_Sqlite.sql
# curl https://raw.githubusercontent.com/lerocha/chinook-database/master/ChinookDatabase/DataSources/Chinook_Sqlite.sql -o Chinook_Sqlite.sql

# 创建Chinook.db
# sqlite3 Chinook.db
# .read Chinook_Sqlite.sql
# SELECT * FROM Artist LIMIT 10;
1|AC/DC
2|Accept
3|Aerosmith
4|Alanis Morissette
5|Alice In Chains
6|Antônio Carlos Jobim
7|Apocalyptica
8|Audioslave
9|BackBeat
10|Billy Cobham
# .exit

from langchain_openai import ChatOpenAI
from pydantic.v1 import SecretStr
from langchain_community.utilities.sql_database import SQLDatabase
from langchain.chains import create_sql_query_chain
from langchain_community.tools.sql_database.tool import QuerySQLDataBaseTool
from operator import itemgetter

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_core.runnables import RunnablePassthrough


api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


def main():
    db = SQLDatabase.from_uri("sqlite:///Chinook.db")
    print(db.dialect)
    print(db.get_usable_table_names())

    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)
    # 问题转化为SQL查询
    chain = create_sql_query_chain(llm, db)
    response = chain.invoke({"question": "How many employees are there"})
    print(response)

    # 执行SQL查询
    execute_query = QuerySQLDataBaseTool(db=db)
    write_query = create_sql_query_chain(llm, db)
    chain = write_query | execute_query
    print(chain.invoke({"question": "How many employees are there"}))

    # 回答问题
    answer_prompt = PromptTemplate.from_template(
        """Given the following user question, corresponding SQL query, and SQL result, answer the user question.

    Question: {question}
    SQL Query: {query}
    SQL Result: {result}
    Answer: """
    )

    answer = answer_prompt | llm | StrOutputParser()
    chain = (
        RunnablePassthrough.assign(query=write_query).assign(
            result=itemgetter("query") | execute_query
        )
        | answer
    )
    print(chain.invoke({"question": "How many employees are there"}))


if __name__ == "__main__":
    main()

sqlite
['Album', 'Artist', 'Customer', 'Employee', 'Genre', 'Invoice', 'InvoiceLine', 'MediaType', 'Playlist', 'PlaylistTrack', 'Track']
SELECT COUNT("EmployeeId") AS "TotalEmployees" FROM "Employee"
[(8,)]
There are a total of 8 employees.

from langchain_openai import ChatOpenAI
from pydantic.v1 import SecretStr
from langchain_community.utilities.sql_database import SQLDatabase
from langchain_community.agent_toolkits.sql.base import create_sql_agent


api_key = SecretStr("sk-xxx")
openai_url = "https://api.chatanywhere.com.cn/v1"


def main():
    db = SQLDatabase.from_uri("sqlite:///Chinook.db")
    print(db.dialect)
    print(db.get_usable_table_names())

    llm = ChatOpenAI(
        temperature=0.0,
        api_key=api_key,
        base_url=openai_url)

    agent_executor = create_sql_agent(
        llm, db=db, agent_type="openai-tools", verbose=True)
    agent_executor.invoke(
        {
            "input": "List the total sales per country. Which country's customers spent the most?"
        }
    )


if __name__ == "__main__":
    main()

sqlite
['Album', 'Artist', 'Customer', 'Employee', 'Genre', 'Invoice', 'InvoiceLine', 'MediaType', 'Playlist', 'PlaylistTrack', 'Track']


> Entering new SQL Agent Executor chain...

Invoking: `sql_db_list_tables` with `{}`


Album, Artist, Customer, Employee, Genre, Invoice, InvoiceLine, MediaType, Playlist, PlaylistTrack, Track
Invoking: `sql_db_schema` with `{'table_names': 'Customer, Invoice, InvoiceLine'}`



CREATE TABLE "Customer" (
        "CustomerId" INTEGER NOT NULL, 
        "FirstName" NVARCHAR(40) NOT NULL, 
        "LastName" NVARCHAR(20) NOT NULL, 
        "Company" NVARCHAR(80), 
        "Address" NVARCHAR(70), 
        "City" NVARCHAR(40), 
        "State" NVARCHAR(40), 
        "Country" NVARCHAR(40), 
        "PostalCode" NVARCHAR(10), 
        "Phone" NVARCHAR(24), 
        "Fax" NVARCHAR(24), 
        "Email" NVARCHAR(60) NOT NULL, 
        "SupportRepId" INTEGER, 
        PRIMARY KEY ("CustomerId"), 
        FOREIGN KEY("SupportRepId") REFERENCES "Employee" ("EmployeeId")
)

/*
3 rows from Customer table:
CustomerId      FirstName       LastName        Company Address City    State   Country PostalCode      Phone    Fax     Email   SupportRepId
1       Luís    Gonçalves       Embraer - Empresa Brasileira de Aeronáutica S.A.        Av. Brigadeiro Faria Lima, 2170  São José dos Campos     SP      Brazil  12227-000       +55 (12) 3923-5555      +55 (12) 3923-5566       luisg@embraer.com.br    3
2       Leonie  Köhler  None    Theodor-Heuss-Straße 34 Stuttgart       None    Germany 70174   +49 0711 2842222 None    leonekohler@surfeu.de   5
3       François        Tremblay        None    1498 rue Bélanger       Montréal        QC      Canada  H2G 1A7  +1 (514) 721-4711       None    ftremblay@gmail.com     3
*/


CREATE TABLE "Invoice" (
        "InvoiceId" INTEGER NOT NULL, 
        "CustomerId" INTEGER NOT NULL, 
        "InvoiceDate" DATETIME NOT NULL, 
        "BillingAddress" NVARCHAR(70), 
        "BillingCity" NVARCHAR(40), 
        "BillingState" NVARCHAR(40), 
        "BillingCountry" NVARCHAR(40), 
        "BillingPostalCode" NVARCHAR(10), 
        "Total" NUMERIC(10, 2) NOT NULL, 
        PRIMARY KEY ("InvoiceId"), 
        FOREIGN KEY("CustomerId") REFERENCES "Customer" ("CustomerId")
)

/*
3 rows from Invoice table:
InvoiceId       CustomerId      InvoiceDate     BillingAddress  BillingCity     BillingState    BillingCountry   BillingPostalCode       Total
1       2       2021-01-01 00:00:00     Theodor-Heuss-Straße 34 Stuttgart       None    Germany 70174   1.98
2       4       2021-01-02 00:00:00     Ullevålsveien 14        Oslo    None    Norway  0171    3.96
3       8       2021-01-03 00:00:00     Grétrystraat 63 Brussels        None    Belgium 1000    5.94
*/


CREATE TABLE "InvoiceLine" (
        "InvoiceLineId" INTEGER NOT NULL, 
        "InvoiceId" INTEGER NOT NULL, 
        "TrackId" INTEGER NOT NULL, 
        "UnitPrice" NUMERIC(10, 2) NOT NULL, 
        "Quantity" INTEGER NOT NULL, 
        PRIMARY KEY ("InvoiceLineId"), 
        FOREIGN KEY("TrackId") REFERENCES "Track" ("TrackId"), 
        FOREIGN KEY("InvoiceId") REFERENCES "Invoice" ("InvoiceId")
)

/*
3 rows from InvoiceLine table:
InvoiceLineId   InvoiceId       TrackId UnitPrice       Quantity
1       1       2       0.99    1
2       1       4       0.99    1
3       2       6       0.99    1
*/
Invoking: `sql_db_query` with `{'query': 'SELECT BillingCountry AS Country, SUM(Total) AS TotalSales FROM Invoice GROUP BY BillingCountry ORDER BY TotalSales DESC;'}`
responded: To find the total sales per country, we need to sum the total amount from the invoices for each country. Here is the query to achieve this:

```sql
SELECT BillingCountry AS Country, SUM(Total) AS TotalSales
FROM Invoice
GROUP BY BillingCountry
ORDER BY TotalSales DESC;
```

By running this query, we can determine which country's customers spent the most. Let me execute the query to provide you with the answer.

[('USA', 523.0600000000003), ('Canada', 303.9599999999999), ('France', 195.09999999999994), ('Brazil', 190.09999999999997), ('Germany', 156.48), ('United Kingdom', 112.85999999999999), ('Czech Republic', 90.24000000000001), ('Portugal', 77.23999999999998), ('India', 75.25999999999999), ('Chile', 46.62), ('Ireland', 45.62), ('Hungary', 45.62), ('Austria', 42.62), ('Finland', 41.620000000000005), ('Netherlands', 40.62), ('Norway', 39.62), ('Sweden', 38.620000000000005), ('Poland', 37.620000000000005), ('Italy', 37.620000000000005), ('Denmark', 37.620000000000005), ('Australia', 37.620000000000005), ('Argentina', 37.620000000000005), ('Spain', 37.62), ('Belgium', 37.62)]The total sales per country are as follows:

1. USA: $523.06
2. Canada: $303.96
3. France: $195.10
4. Brazil: $190.10
5. Germany: $156.48

Therefore, customers from the USA spent the most in total sales.

> Finished chain.

import time
from langchain_openai import ChatOpenAI
from langchain_community.callbacks import get_openai_callback

IS_OLLAMA = True

# 初始化OpenAI LLM
if IS_OLLAMA:
    llm = ChatOpenAI(
        base_url="https://openllm.xxx.com/v1",
        api_key="ollama",
        model="qwen:7b",
        max_tokens=2000,
        temperature=0)
else:
    llm = ChatOpenAI(
        base_url="http://xxx:9000/v1",
        api_key="ollama",
        model="Qwen1.5-7B-Chat",
        max_tokens=2000,
        temperature=0)

# 启动回调函数
with get_openai_callback() as cb:
    start_time = time.time()

    # 生成一些文本
    output = llm.invoke("作为一个旅游资深博主，请写一篇关于巴厘岛的文章，不少于2000字。")
    end_time = time.time()
    elapsed_time = end_time - start_time

    # 获取生成的token数量
    total_tokens = cb.total_tokens

# 计算token生成速率
token_rate = total_tokens / elapsed_time
print(f"生成了 {total_tokens} 个token, 用时 {elapsed_time:.2f} 秒")
print(f"Token生成速率为 {token_rate:.2f} tokens/秒")

# vim Modelfile
FROM ./test-33b.Q4_0.gguf

# ollama create example -f Modelfile

# vim /etc/systemd/system/ollama.service
[Unit]
Description=Ollama Service
After=network-online.target

[Service]
ExecStart=/usr/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
# 开启debug模式，可以看到更多输出日志
Environment="OLLAMA_DEBUG=1"
Environment="OLLAMA_HOST=0.0.0.0"
# 绑定GPU卡，通过nvidia-smi -L可以查到，多卡使用逗号隔开
Environment="CUDA_VISIBLE_DEVICES=GPU-18089521-10dd-9d6a-88df-cabf9d427d43"
# 最大显存使用，单位byte
Environment="OLLAMA_MAX_VRAM=23192823398"
# 模型加载到显存中的过期时间
Environment="OLLAMA_KEEP_ALIVE=5m"
# 动态库，强制使用GPU，默认情况下在GPU不足的情况下会使用cpu
Environment="OLLAMA_LLM_LIBRARY=cuda_v11"

[Install]
WantedBy=default.target

# pip3 install -U huggingface_hub

[root@localhost ~]# huggingface-cli env

Copy-and-paste the text below in your GitHub issue.

- huggingface_hub version: 0.20.3
- Platform: Linux-4.19.90-23.43.v2101.ky10.x86_64-x86_64-with-glibc2.28
- Python version: 3.11.7
- Running in iPython ?: No
- Running in notebook ?: No
- Running in Google Colab ?: No
- Token path ?: /root/.cache/huggingface/token
- Has saved token ?: False
- Configured git credential helpers:
- FastAI: N/A
- Tensorflow: N/A
- Torch: 2.1.2
- Jinja2: 3.1.3
- Graphviz: N/A
- Pydot: N/A
- Pillow: 10.2.0
- hf_transfer: N/A
- gradio: N/A
- tensorboard: N/A
- numpy: 1.26.3
- pydantic: 1.10.13
- aiohttp: N/A
- ENDPOINT: https://huggingface.co
- HF_HUB_CACHE: /root/.cache/huggingface/hub
- HF_ASSETS_CACHE: /root/.cache/huggingface/assets
- HF_TOKEN_PATH: /root/.cache/huggingface/token
- HF_HUB_OFFLINE: False
- HF_HUB_DISABLE_TELEMETRY: False
- HF_HUB_DISABLE_PROGRESS_BARS: None
- HF_HUB_DISABLE_SYMLINKS_WARNING: False
- HF_HUB_DISABLE_EXPERIMENTAL_WARNING: False
- HF_HUB_DISABLE_IMPLICIT_TOKEN: False
- HF_HUB_ENABLE_HF_TRANSFER: False
- HF_HUB_ETAG_TIMEOUT: 10
- HF_HUB_DOWNLOAD_TIMEOUT: 10

[root@localhost ~]# export HF_ENDPOINT=https://hf-mirror.com

# 创建模型目录，用于存放下载的模型文件
[root@localhost ~]# mkdir -p /opt/ice/models/qwen-14b-chat 

[root@localhost ~]# huggingface-cli download \
--resume-download --local-dir-use-symlinks False \
--local-dir /opt/ice/models/qwen-14b-chat \
qwen/qwen-14b-chat
Consider using `hf_transfer` for faster downloads. This solution comes with some limitations. See https://huggingface.co/docs/huggingface_hub/hf_transfer for more details.
Fetching 37 files:   0%|                                                                                                                              | 0/37 [00:00<?, ?it/s]downloading https://hf-mirror.com/qwen/qwen-14b-chat/resolve/cdaff792392504e679496a9f386acf3c1e4333a5/.gitattributes to /root/.cache/huggingface/hub/models--qwen--qwen-14b-chat/blobs/a6344aac8c09253b3b630fb776ae94478aa0275b.incomplete
downloading https://hf-mirror.com/qwen/qwen-14b-chat/resolve/cdaff792392504e679496a9f386acf3c1e4333a5/LICENSE to /root/.cache/huggingface/hub/models--qwen--qwen-14b-chat/blobs/5be33384d19169a98eee863ff09c74eb32e37696.incomplete

[root@localhost]# yum install -y nvidia-container-toolkit nvidia-container-runtime

[root@localhost]# nvidia-ctk runtime configure --runtime=docker
INFO[0000] Loading docker config from /etc/docker/daemon.json
INFO[0000] Config file does not exist, creating new one
INFO[0000] Wrote updated config to /etc/docker/daemon.json
INFO[0000] It is recommended that the docker daemon be restarted.
[root@localhost qwen-14b]# cat /etc/docker/daemon.json
{
    "runtimes": {
        "nvidia": {
            "args": [],
            "path": "nvidia-container-runtime"
        }
    }
}

[root@localhost]# systemctl restart docker

[root@localhost]# docker run --rm --runtime=nvidia --gpus all ubuntu nvidia-smi

# git clone https://github.com/xusenlinzy/api-for-open-llm.git

# cd api-for-open-llm/
# cp .env.example .env

[root@localhost api-for-open-llm]# vim .env
PORT=8000

# model related
MODEL_NAME=qwen      # 模型名
MODEL_PATH=/opt/ice/models/qwen-14b-chat # 下载好的模型文件路径
EMBEDDING_NAME=
ADAPTER_MODEL_PATH=
QUANTIZE=16
CONTEXT_LEN=
LOAD_IN_8BIT=false
LOAD_IN_4BIT=false
USING_PTUNING_V2=false
STREAM_INTERVERL=2
PROMPT_NAME=

# device related
DEVICE=

# "auto", "cuda:0", "cuda:1", ...
DEVICE_MAP=auto
GPUS=
NUM_GPUs=2
DTYPE=half

# api related
API_PREFIX=/v1

USE_STREAMER_V2=false
ENGINE=default

[root@localhost api-for-open-llm]# docker build -f docker/Dockerfile -t llm-api:pytorch .

[root@localhost api-for-open-llm]# docker run -it -d \
--gpus all \
--ipc=host -p 8000:8000 \
--name=llm-api --ulimit memlock=-1 \
--ulimit stack=67108864 \
-v `pwd`:/workspace -v /opt/ice/models/qwen-14b-chat:/opt/ice/models/qwen-14b-chat \
llm-api:pytorch \
python api/server.py

[root@localhost api-for-open-llm]# docker logs -f llm-api
=============
== PyTorch ==
=============

NVIDIA Release 23.10 (build 71422337)
PyTorch Version 2.1.0a0+32f93b1

Container image Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.

Copyright (c) 2014-2023 Facebook Inc.
Copyright (c) 2011-2014 Idiap Research Institute (Ronan Collobert)
Copyright (c) 2012-2014 Deepmind Technologies    (Koray Kavukcuoglu)
Copyright (c) 2011-2012 NEC Laboratories America (Koray Kavukcuoglu)
Copyright (c) 2011-2013 NYU                      (Clement Farabet)
Copyright (c) 2006-2010 NEC Laboratories America (Ronan Collobert, Leon Bottou, Iain Melvin, Jason Weston)
Copyright (c) 2006      Idiap Research Institute (Samy Bengio)
Copyright (c) 2001-2004 Idiap Research Institute (Ronan Collobert, Samy Bengio, Johnny Mariethoz)
Copyright (c) 2015      Google Inc.
Copyright (c) 2015      Yangqing Jia
Copyright (c) 2013-2016 The Caffe contributors
All rights reserved.

Various files include modifications (c) NVIDIA CORPORATION & AFFILIATES.  All rights reserved.

This container image and its contents are governed by the NVIDIA Deep Learning Container License.
By pulling and using the container, you accept the terms and conditions of this license:
https://developer.nvidia.com/ngc/nvidia-deep-learning-container-license

2024-02-01 01:53:11.597 | DEBUG    | api.config:<module>:265 - SETTINGS: {
    "host": "0.0.0.0",
    "port": 8000,
    "api_prefix": "/v1",
    "engine": "default",
    "model_name": "qwen",
    "model_path": "/opt/ice/models/qwen-14b-chat",
    "adapter_model_path": null,
    "resize_embeddings": false,
    "dtype": "half",
    "device": "cuda",
    "device_map": "auto",
    "gpus": null,
    "num_gpus": 2,
    "only_embedding": false,
    "embedding_name": null,
    "embedding_size": -1,
    "embedding_device": "cuda",
    "quantize": 16,
    "load_in_8bit": false,
    "load_in_4bit": false,
    "using_ptuning_v2": false,
    "pre_seq_len": 128,
    "context_length": -1,
    "chat_template": null,
    "rope_scaling": null,
    "flash_attn": false,
    "trust_remote_code": false,
    "tokenize_mode": "auto",
    "tensor_parallel_size": 1,
    "gpu_memory_utilization": 0.9,
    "max_num_batched_tokens": -1,
    "max_num_seqs": 256,
    "quantization_method": null,
    "use_streamer_v2": false,
    "api_keys": null,
    "activate_inference": true,
    "interrupt_requests": true,
    "n_gpu_layers": 0,
    "main_gpu": 0,
    "tensor_split": null,
    "n_batch": 512,
    "n_threads": 24,
    "n_threads_batch": 24,
    "rope_scaling_type": -1,
    "rope_freq_base": 0.0,
    "rope_freq_scale": 0.0,
    "tgi_endpoint": null,
    "tei_endpoint": null,
    "max_concurrent_requests": 256,
    "max_client_batch_size": 32
}
2024-02-01 01:53:22.457 | INFO     | api.adapter.patcher:patch_tokenizer:119 - Add eos token: <|endoftext|>
2024-02-01 01:53:22.457 | INFO     | api.adapter.patcher:patch_tokenizer:126 - Add pad token: <|endoftext|>
/root/.cache/huggingface/modules/transformers_modules/qwen-14b-chat/modeling_qwen.py:969: DeprecationWarning: The 'warn' method is deprecated, use 'warning' instead
  logger.warn("Try importing flash-attention for faster inference...")
Try importing flash-attention for faster inference...
Warning: import flash_attn rotary fail, please install FlashAttention rotary to get higher efficiency https://github.com/Dao-AILab/flash-attention/tree/main/csrc/rotary
Warning: import flash_attn rms_norm fail, please install FlashAttention layer_norm to get higher efficiency https://github.com/Dao-AILab/flash-attention/tree/main/csrc/layer_norm
Loading checkpoint shards: 100% 15/15 [00:06<00:00,  2.41it/s]
2024-02-01 01:53:29.693 | INFO     | api.models:create_generate_model:61 - Using default engine
2024-02-01 01:53:29.693 | INFO     | api.core.default:_check_construct_prompt:128 - Using Qwen Model for Chat!
INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

FlashAttention-2 currently supports:

Ampere, Ada, or Hopper GPUs (e.g., A100, RTX 3090, RTX 4090, H100). Support for Turing GPUs (T4, RTX 2080) is coming soon, please use FlashAttention 1.x for Turing GPUs for now.
Datatype fp16 and bf16 (bf16 requires Ampere, Ada, or Hopper GPUs).
All head dimensions up to 256. Head dim > 192 backward requires A100/A800 or H100/H800.

[root@localhost]# vim Dockerfile
# 使用vllm/vllm-openai作为基础镜像
FROM vllm/vllm-openai:v0.3.0

# 通义千问需要额外安装包
RUN pip install tiktoken \
  -i https://pypi.tuna.tsinghua.edu.cn/simple

[root@localhost]# docker build -f Dockerfile -t vllm/vllm-openai:kylin-v10 .

[root@localhost]# docker run -it -d \
--gpus all -v /opt/ice/models/qwen-14b-chat:/opt/qwen-14b-chat \
--name vllm-api \
-p 8000:8000 --ipc=host \
vllm/vllm-openai:kylin-v10 \
--model /opt/qwen-14b-chat \
--max-model-len 8096
--enforce-eager \
--trust-remote-code \
--tensor-parallel-size 2

[root@localhost vllm]# docker logs -f vllm-api
INFO 02-01 10:14:02 api_server.py:727] args: Namespace(host=None, port=8000, allow_credentials=False, allowed_origins=['*'], allowed_methods=['*'], allowed_headers=['*'], served_model_name=None, chat_template=None, response_role='assistant', ssl_keyfile=None, ssl_certfile=None, model='/opt/qwen-14b-chat', tokenizer=None, revision=None, tokenizer_revision=None, tokenizer_mode='auto', trust_remote_code=True, download_dir=None, load_format='auto', dtype='auto', max_model_len=None, worker_use_ray=False, pipeline_parallel_size=1, tensor_parallel_size=2, max_parallel_loading_workers=None, block_size=16, seed=0, swap_space=4, gpu_memory_utilization=0.9, max_num_batched_tokens=None, max_num_seqs=256, max_paddings=256, disable_log_stats=False, quantization=None, enforce_eager=True, max_context_len_to_capture=8192, engine_use_ray=False, disable_log_requests=False, max_log_len=None)
2024-02-01 10:14:07,259	INFO worker.py:1724 -- Started a local Ray instance.

INFO 02-01 10:14:08 llm_engine.py:70] Initializing an LLM engine with config: model='/opt/qwen-14b-chat', tokenizer='/opt/qwen-14b-chat', tokenizer_mode=auto, revision=None, tokenizer_revision=None, trust_remote_code=True, dtype=torch.float16, max_seq_len=2048, download_dir=None, load_format=auto, tensor_parallel_size=2, quantization=None, enforce_eager=True, seed=0)
WARNING 02-01 10:14:09 tokenizer.py:62] Using a slow tokenizer. This might cause a significant slowdown. Consider using a fast tokenizer instead.
INFO 02-01 10:14:23 llm_engine.py:275] # GPU blocks: 981, # CPU blocks: 655
WARNING 02-01 10:14:25 tokenizer.py:62] Using a slow tokenizer. This might cause a significant slowdown. Consider using a fast tokenizer instead.
WARNING 02-01 10:14:25 api_server.py:123] No chat template provided. Chat API will not work.
INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

[root@localhost ~]# curl http://localhost:8000/v1/completions -H "Content-Type: application/json" -d '{"model": "/opt/qwen-14b-chat","prompt": "Hi,深圳排名前十的好玩的公园？","max_tokens": 1000,"temperature": 0, "stop": "<|endoftext|>"}'

# 输出
{
    "id": "cmpl-dcee971a-fc6b-45f5-bd56-d7433553d9e5",
    "choices": [
        {
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null,
            "text": "深圳有哪些好玩的公园呢？公园里景色优美，空气清新，是休闲放松的好去处。\n深圳公园多，而且多有特色，比如深圳湾公园、莲花山公园、笔架山公园、洪湖公园、大梅沙海滨公园等等，都是深圳市民和游客经常去的地方。这些公园各有特色，各有特色，各有各自的特色。\n如果时间充足，可以一一游玩。如果时间紧凑，可以挑选一些有代表性的公园游玩。今天就带大家游览一下深圳十大公园。\n深圳湾公园位于深圳市南山区西部，东临深圳湾，西至白石洲，北靠福田区，南接蛇口。公园包括深圳湾栈道、深圳湾运动公园、深圳湾休闲文化公园等。深圳湾公园是深圳最浪漫的公园，最适合新人拍摄婚纱照，也适合全家出游。\n莲花山公园位于深圳市中心区北端红荔路与新洲路交汇处，占地194公顷，是深圳最大的公园。公园包括山顶广场、风筝广场、观景台、莲花山音乐厅、深圳改革开放展览馆等。莲花山公园是深圳市民最喜欢的公园之一，也是深圳最著名的公园。\n笔架山公园位于深圳市中心区，北临深南大道，西接福华三路。公园包括笔架山、笔架山公墓、笔架山儿童公园、笔架山植物园等。笔架山公园是深圳最安静的公园，最适合周末休闲。\n洪湖公园位于深圳市中心区，南临深南大道，北接红荔路，东临深南大道，西接华强北路。公园包括洪湖、洪湖公园、洪湖街、洪湖街等。洪湖公园是深圳最浪漫的公园，最适合新人拍摄婚纱照，也适合全家出游。\n大梅沙海滨公园位于深圳市盐田区东部，西临大梅沙海滨，东至盐田港。公园包括大梅沙海滨、大梅沙海滨公园、大梅沙海滨步行街等。大梅沙海滨公园是深圳最受欢迎的公园，也是深圳最著名的公园。\n深圳湾公园、莲花山公园、笔架山公园、洪湖公园、大梅沙海滨公园都是深圳市民和游客经常去的地方，也是深圳最受欢迎的公园。\n深圳湾公园位于深圳市南山区西部，东临深圳湾，西至白石洲，北靠福田区，南接蛇口。公园包括深圳湾栈道、深圳湾运动公园、深圳湾休闲文化公园等。深圳湾公园是深圳最浪漫的公园，最适合新人拍摄婚纱照，也适合全家出游。\n莲花山公园位于深圳市中心区北端红荔路与新洲路交汇处，占地194公顷，是深圳最大的公园。公园包括山顶广场、风筝广场、观景台、莲花山音乐厅、深圳改革开放展览馆等。莲花山公园是深圳市民最喜欢的公园之一，也是深圳最著名的公园。\n笔架山公园位于深圳市中心区，北临深南大道，西接福华三路。公园包括笔架山、笔架山公墓、笔架山儿童公园、笔架山植物园等。笔架山公园是深圳最安静的公园，最适合周末休闲。\n洪湖公园位于深圳市中心区，南临深南大道，北接红荔路，东临深南大道，西接华强北路。公园包括洪湖、洪湖公园、洪湖街、洪湖街等。洪湖公园是深圳最浪漫的公园，最适合新人拍摄婚纱照，也适合全家出游。\n大梅沙海滨公园位于深圳市盐田区东部，西临大梅沙海滨，东至盐田港。公园包括大梅沙海滨、大梅沙海滨公园、大梅沙海滨步行街等。大梅沙海滨公园是深圳最受欢迎的公园，也是深圳最著名的公园。\n以上就是深圳十大公园，包括深圳湾公园、莲花山公园、笔架山公园、洪湖公园、大梅沙海滨公园等。深圳十大公园各有特色，各有特色，各有各自的特色。"
        }
    ],
    "created": 1706767165,
    "model": "/opt/qwen-14b-chat",
    "object": "text_completion",
    "system_fingerprint": null,
    "usage": {
        "completion_tokens": 859,
        "prompt_tokens": 10,
        "total_tokens": 869
    }
}

CUDA out of memory. Tried to allocate 1024.00 MiB (GPU 0; 7.80 GiB total capacity; 5.21 GiB already allocated; 
173.38 MiB free; 5.27 GiB reserved in total by PyTorch) 
If reserved memory is >> allocated memory try setting max_split_size_mb to avoid fragmentation. 
See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF

# wget -c https://download.docker.com/linux/static/stable/aarch64/docker-20.10.9.tgz
# tar xf docker-20.10.9.tgz
# cp -p docker/* /usr/bin/

# vim /usr/lib/systemd/system/docker.service

[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target docker.socket firewalld.service containerd.service
Wants=network-online.target
Requires=docker.socket containerd.service

[Service]
Type=notify
# the default is not to use systemd for cgroups because the delegate issues still
# exists and systemd currently does not support the cgroup feature set required
# for containers run by docker
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutStartSec=0
RestartSec=2
Restart=always

# Note that StartLimit* options were moved from "Service" to "Unit" in systemd 229.
# Both the old, and new location are accepted by systemd 229 and up, so using the old location
# to make them work for either version of systemd.
StartLimitBurst=3

# Note that StartLimitInterval was renamed to StartLimitIntervalSec in systemd 230.
# Both the old, and new name are accepted by systemd 230 and up, so using the old name to make
# this option work for either version of systemd.
StartLimitInterval=60s

# Having non-zero Limit*s causes performance problems due to accounting overhead
# in the kernel. We recommend using cgroups to do container-local accounting.
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity

# Comment TasksMax if your systemd version does not support it.
# Only systemd 226 and above support this option.
TasksMax=infinity

# set delegate yes so that systemd does not reset the cgroups of docker containers
Delegate=yes

# kill only the docker process, not all processes in the cgroup
KillMode=process
OOMScoreAdjust=-500

[Install]
WantedBy=multi-user.target

# vim /usr/lib/systemd/system/docker.socket

[Unit]
Description=Docker Socket for the API

[Socket]
# If /var/run is not implemented as a symlink to /run, you may need to
# specify ListenStream=/var/run/docker.sock instead.
ListenStream=/run/docker.sock
SocketMode=0660
SocketUser=root
SocketGroup=docker

[Install]
WantedBy=sockets.target

# vim /usr/lib/systemd/system/containerd.service

[Unit]
Description=containerd container runtime
Documentation=https://containerd.io
After=network.target local-fs.target

[Service]
ExecStartPre=-/sbin/modprobe overlay
ExecStart=/usr/bin/containerd

Type=notify
Delegate=yes
KillMode=process
Restart=always
RestartSec=5
# Having non-zero Limit*s causes performance problems due to accounting overhead
# in the kernel. We recommend using cgroups to do container-local accounting.
LimitNPROC=infinity
LimitCORE=infinity
LimitNOFILE=infinity
# Comment TasksMax if your systemd version does not supports it.
# Only systemd 226 and above support this version.
TasksMax=infinity
OOMScoreAdjust=-999

[Install]
WantedBy=multi-user.target

# groupadd docker
# systemctl daemon-reload
# systemctl start docker
# systemctl enable docker

# docker info

Client:
 Context:    default
 Debug Mode: false

Server:
 Containers: 0
  Running: 0
  Paused: 0
  Stopped: 0
 Images: 0
 Server Version: 20.10.9
 Storage Driver: overlay2
  Backing Filesystem: xfs
  Supports d_type: true
  Native Overlay Diff: true
  userxattr: false
 Logging Driver: json-file
 Cgroup Driver: cgroupfs
 Cgroup Version: 1
 Plugins:
  Volume: local
  Network: bridge host ipvlan macvlan null overlay
  Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog
 Swarm: inactive
 Runtimes: io.containerd.runc.v2 io.containerd.runtime.v1.linux runc
 Default Runtime: runc
 Init Binary: docker-init
 containerd version: 5b46e404f6b9f661a205e28d59c982d3634148f8
 runc version: v1.0.2-0-g52b36a2d
 init version: de40ad0
 Security Options:
  seccomp
   Profile: default
 Kernel Version: 4.19.90-23.8.v2101.ky10.aarch64
 Operating System: Kylin Linux Advanced Server V10 (Tercel)
 OSType: linux
 Architecture: aarch64
 CPUs: 128
 Total Memory: 1.996TiB
 Name: localhost.localdomain
 ID: PI7U:7E6V:4CJA:YEJP:KXIU:YJ4S:24JA:CS6L:ONVR:FNMO:PCHW:RNJ7
 Docker Root Dir: /var/lib/docker
 Debug Mode: false
 Registry: https://index.docker.io/v1/
 Labels:
 Experimental: false
 Insecure Registries:
  127.0.0.0/8
 Live Restore Enabled: false
 Product License: Community Engine

# 先在联网机器上下载docker镜像
docker pull quay.io/coreos/etcd:v3.5.5
docker pull minio/minio:RELEASE.2023-03-20T20-16-18Z
docker pull milvusdb/milvus:v2.3.4
docker pull mysql:latest
docker pull freeren/qanything:v1.2.1

# 打包镜像
docker save quay.io/coreos/etcd:v3.5.5 minio/minio:RELEASE.2023-03-20T20-16-18Z milvusdb/milvus:v2.3.4 mysql:latest freeren/qanything:v1.2.1 -o qanything_offline.tar

# 下载QAnything代码
wget https://github.com/netease-youdao/QAnything/archive/refs/heads/master.zip

# 把镜像qanything_offline.tar和代码QAnything-master.zip拷贝到断网机器上
cp master.zip qanything_offline.tar /path/to/your/offline/machine

# 在断网机器上加载镜像
docker load -i qanything_offline.tar

# 解压代码，运行
unzip master.zip
cd QAnything-master
bash run.sh