Agent开发

1
@RestController
2
@RequestMapping("/promt/engineer")
3
public class PromtEngineerController implements InitializingBean {
4
    @Autowired
5
    private ChatModel chatModel;
6
    private ChatClient chatClient;
7
@GetMapping("/role")
8
public String role(String message) {
9
    return chatClient.prompt(message).call().content();
10

11
}
12
    @Override
13
    public void afterPropertiesSet() throws Exception {
14
        chatClient=ChatClient.builder(chatModel)
15
                .defaultSystem("你是一个毒舌博主，说话很噎人，请根据用户问题，怼他")
16
                .build();
17
    }
18
}

1
 @GetMapping("/shot")
2
    public String shot(String message) {
3
        return chatClient.prompt().system("""
4
                请你根据用户输入的问题做改写，主要有以下改写策略：
5
                1、改写其中的错别字。
6
                2、做内容精简，帮用户的一堆废话精简成简单的一句话
7
                可以参考以下实例：
8

9
                Input：ni好
10
                Output ：{"错别字改写":"你好","内容精简":""}
11

12
                Input：我今天心情不错，我想知道今天是什么天气才让我心情这么好的？
13
                Output ：{"错别字改写":"","内容精简":"今天是什么天气？"}
14

15
                """).user(message).call().content();
16
    }

1
@RestController
2
@RequestMapping("/stream/output")
3
public class SseEmitterController {
4
    @GetMapping("/sse/emitter")
5
    public SseEmitter sse() {
6
        SseEmitter emitter = new SseEmitter(60_000L); // 设置超时时间
7
      //创建虚拟线程
8
        Executors.newSingleThreadExecutor().submit(() -> {
9
            try {
10
                for (int i = 0; i < 10; i++) {
11
                    emitter.send("Message " + i);
12
                    Thread.sleep(1000);
13
                }
14
                emitter.complete();
15
            } catch (Exception ex) {
16
                emitter.completeWithError(ex);
17
            }
18
        });
19

20
        return emitter;
21
    }
22
}

1
@GetMapping("/sse/streaming")
2
public ResponseEntity<StreamingResponseBody> chat() {
3
    StreamingResponseBody body = outputStream -> {
4
        for (int i = 0; i < 10; i++) {
5
            String data = "data chunk " + i + "\n";
6
            outputStream.write(data.getBytes(StandardCharsets.UTF_8));
7
            outputStream.flush();
8
            try {
9
                Thread.sleep(500); // 模拟延迟
10
            } catch (InterruptedException e) {
11
                throw new RuntimeException(e);
12
            }
13
        }
14
    };
15

16
    return ResponseEntity.ok()
17
            .header(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_EVENT_STREAM_VALUE)
18
            .body(body);
19
}

1
from langchain.text_splitter import RecursiveCharacterTextSplitter
2
from langchain.embeddings import OpenAIEmbeddings
3
from langchain.vectorstores import Pinecone
4
import pinecone
5

6
#1. 读取文档
7
with open("medical_docs.txt", "r") as f:
8
    document = f.read()
9

10
#2. 分块
11
text_splitter = RecursiveCharacterTextSplitter(
12
    chunk_size=500,
13
    chunk_overlap=50,
14
    separators=["\n\n", "\n", "。", "！", "？", "，"]
15
)
16
chunks = text_splitter.split_text(document)
17

18
#3. 初始化embedding模型
19
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
20

21
#4. 初始化向量数据库
22
pinecone.init(api_key="your-key")
23
index_name = "medical-rag"
24

25
#5. 创建索引并存储
26
vectorstore = Pinecone.from_texts(
27
    texts=chunks,
28
    embedding=embeddings,
29
    index_name=index_name
30
)
31

32
print(f"成功索引了 {len(chunks)} 个文本块！")

1
#用户问题
2
question = "阿司匹林有哪些副作用？"
3

4
#问题向量化
5
question_embedding = embeddings.embed_query(question)
6

7
#向量检索（找最相似的3个）
8
results = vectorstore.similarity_search_by_vector(
9
    embedding=question_embedding,
10
    k=3  # 返回top3
11
)
12

13
for i, doc in enumerate(results):
14
    print(f"结果{i+1}:")
15
    print(doc.page_content)
16
    print(f"相似度: {doc.metadata['score']}")
17
    print("-" * 50)

1
结构化提示词
2

3
# Role
4

5
你是一个专业的企业知识库助手。你的任务是根据提供的【参考文档】回答用户的问题。
6

7
# Rules（关键！防幻觉指令）
8

9
1. 必须**仅依赖**下方的【参考文档】进行回答，不要使用你内部的训练知识。
10
2. 如果【参考文档】中没有包含回答问题所需的信息，请直接回答：“知识库中未找到相关信息”。
11
3. 回答需要逻辑清晰，分点表述。
12
4. 如果可能，请在回答的末尾注明引用的文档名称。
13

14
# Context（检索到的片段）
15

16
以下是参考文档片段：
17

18
<context>
19
{context_str}
20
</context>
21

22
# User Question
23

24
用户的问题是：
25
{query_str}
26

27
# Answer
28
请开始回答：
29

30

31
Few-Short少量样本
32
方法二：给予示例工程
33
示例1
34
示例2

1
# 角色定义
2
你是一名专业的旅行规划顾问，擅长根据用户偏好制定个性化的旅游计划。
3
你需要以Markdown格式输出一份简洁、清晰、实用的行程安排。
4
---
5
# 任务描述
6
根据用户输入的出行需求（如目的地、天数、兴趣点等），制定一个详细的旅行计划。
7
要求内容包括：
8
1. 每日行程安排（含景点、交通、餐饮推荐）
9
2. 总体花费预估（以人民币计）
10
3. 温馨提示（如天气、穿衣建议、注意事项）
11
---
12
# 景点参考信息（上下文信息）
13
以下是部分城市旅游参考资料（供你在规划时参考）：
14
[文档片段1]
15
北京以历史文化景点为主，热门景点包括故宫、长城、颐和园。春秋季节气候宜人，适合户外活动。
16

17
[文档片段2]
18
上海以现代都市景观与夜景闻名，热门景点包括外滩、迪士尼、豫园。地铁交通便利，美食多样。
19

20
[文档片段3]
21
成都以美食和休闲文化著称，热门景点包括宽窄巷子、大熊猫基地、都江堰，节奏悠闲，消费亲民。
22
---
23
# 示例
24
## 示例1：
25
输入：我想去北京玩两天，主要想看名胜古迹。
26
输出：
27
```markdown
28
  # 北京两日游行程规划
29

30
  ## 第一天：历史文化探索
31
  - 上午：参观 **故宫**
32
  - 下午：游览 **天安门广场**、**王府井步行街**
33
  - 晚餐推荐：全聚德烤鸭
34

35
  ## 第二天：自然与皇家园林
36
  - 上午：游览 **颐和园**
37
  - 下午：前往 **八达岭长城**
38
  - 晚餐推荐：老北京炸酱面
39

40
  ### 预算预估
41
  约 ¥1200 / 人（含交通与餐饮）
42

43
  ### 温馨提示
44
  - 早晚温差较大，请带外套。
45
  - 部分景区需提前预约。
46
```
47

48
## 示例2：
49
输入：帮我规划一个上海三天的亲子游。
50
输出：
51
```markdown
52
  # 上海三日亲子游计划
53

54
  ## 第一天：城市初体验
55
  - 上午：参观 **上海自然博物馆**
56
  - 下午：漫步 **外滩**，夜游黄浦江
57
  - 晚餐推荐：蟹粉小笼包
58

59
  ## 第二天：迪士尼奇幻乐园
60
  - 全天游玩 **上海迪士尼乐园**
61
  - 晚餐推荐：园区主题餐厅
62

63
  ## 第三天：城市休闲与购物
64
  - 上午：游览 **豫园**
65
  - 下午：南京路步行街自由活动
66
  - 晚餐推荐：新天地西餐厅
67

68
  ### 预算预估
69
  约 ¥2200 / 人（含门票与住宿）
70

71
  ### 温馨提示
72
  - 提前预约迪士尼门票。
73
  - 夏季炎热，请携带防晒用品。
74
  ```
75

76
---
77

78
# 按照如下格式输出：
79
# <城市+天数>行程规划标题
80

81
## 第一天：
82
- 上午：
83
- 下午：
84
- 晚餐推荐：
85

86
## 第二天：
87
- 上午：
88
- 下午：
89
- 晚餐推荐：
90

91
## 第三天：
92
- 上午：
93
- 下午：
94
- 晚餐推荐：
95

96
### 预算预估
97
### 温馨提示
98

99
---
100

101
# 当前任务
102
请根据以下用户输入，生成Markdown格式的旅行行程方案：
103

104
用户输入：
105
“我打算去成都玩三天，想吃美食也想看看大熊猫。”
106
请确保按照指定的输出格式输出，不要输出多余解释或说明。

1
def rag_query(question):
2
    """完整的RAG查询流程"""
3
    # 1. 检索相关文档
4
    retrieved_docs = vectorstore.similarity_search(question, k=3)
5
    # 2. 构建prompt
6
    context = "\n\n".join([
7
        f"【文档{i+1}】{doc.page_content}"
8
        for i, doc in enumerate(retrieved_docs)
9
    ])
10
    prompt = f"""
11
    参考以下资料回答问题：
12
    {context}
13
    问题：{question}
14
    要求：
15
    1. 回答要准确、专业
16
    2. 必须基于参考资料
17
    3. 标注信息来源
18
    """
19
    # 3. 调用LLM生成
20
    response = client.chat.completions.create(
21
        model="gpt-4",
22
        messages=[{"role": "user", "content": prompt}],
23
        temperature=0.3
24
    )
25
    answer = response.choices[0].message.content
26
    # 4. 添加引用
27
    sources = [
28
        {"title": f"文档{i+1}", "score": doc.metadata.get('score', 0)}
29
        for i, doc in enumerate(retrieved_docs)
30
    ]
31
    return {
32
        "answer": answer,
33
        "sources": sources,
34
        "retrieved_docs": [doc.page_content for doc in retrieved_docs]
35
    }
36

37
#使用示例
38
result = rag_query("阿司匹林有哪些副作用？")
39
print("答案:", result['answer'])
40
print("\n参考来源:", result['sources'])

1
from langchain.llms import OpenAI
2
from langchain.prompts import PromptTemplate
3

4
#步骤1: 问题分解
5
decompose_prompt = PromptTemplate(
6
    template="""
7
    请将以下复杂问题分解为3-6个简单的子问题。
8
    每个子问题应该独立且可以单独回答。
9
    原始问题: {question}
10
    请以JSON列表格式输出子问题:
11
    ["子问题1", "子问题2", "子问题3", ...]
12
    """,
13
    input_variables=["question"]
14
)
15

16
llm = OpenAI(temperature=0.7)
17

18
original_question = "如何搭建一个高性能的RAG系统？需要考虑哪些技术选型和优化策略？"
19

20
#分解问题
21
sub_questions = llm(decompose_prompt.format(question=original_question))
22
sub_questions = json.loads(sub_questions)
23

24
#步骤2: 对每个子问题进行RAG检索和回答
25
sub_answers = []
26
for sub_q in sub_questions:
27
    # 检索相关文档
28
    relevant_docs = vector_db.search(sub_q, top_k=3)
29
    # 生成子答案
30
    answer_prompt = f"""
31
    基于以下文档，回答问题: {sub_q}
32
    文档内容:
33
    {relevant_docs}
34
    请简洁明确地回答:
35
    """
36
    sub_answer = llm(answer_prompt)
37
    sub_answers.append({
38
        "question": sub_q,
39
        "answer": sub_answer
40
    })
41

42
#步骤3: 综合所有子答案
43
synthesis_prompt = f"""
44
你是一个专业的技术专家。现在你需要基于以下子问题和对应的答案，
45
综合生成一个完整、有条理的回答。
46

47
原始问题: {original_question}
48

49
子问题和答案:
50
{json.dumps(sub_answers, ensure_ascii=False, indent=2)}
51

52
请生成一个结构清晰、逻辑连贯的最终答案:
53
"""
54

55
final_answer = llm(synthesis_prompt)
56
print(final_answer)

1
from langchain_openai import ChatOpenAI
2
from langchain_core.prompts import ChatPromptTemplate
3

4
#Step 1: 定义Step Back提示词模板
5
step_back_template = """你是一个世界知识专家。你的任务是把具体问题转化为更通用的回退问题。
6

7
示例：
8
原问题：特斯拉Model 3在2023年Q4的销量是多少？
9
回退问题：特斯拉Model 3历年的销量趋势和数据有哪些？
10

11
原问题：张三在2020-2022年担任什么职位？
12
回退问题：张三的职业生涯发展轨迹是怎样的？
13

14
现在请处理这个问题：
15
原问题：{original_question}
16
回退问题："""
17

18
llm = ChatOpenAI(model="gpt-4", temperature=0.3)
19
step_back_prompt = ChatPromptTemplate.from_template(step_back_template)
20

21
#Step 2: 生成回退问题
22
def generate_step_back_question(original_q):
23
    chain = step_back_prompt | llm
24
    response = chain.invoke({"original_question": original_q})
25
    return response.content
26

27
#Step 3: 使用回退问题进行RAG检索
28
from langchain.vectorstores import FAISS
29
from langchain.embeddings import OpenAIEmbeddings
30

31
def step_back_rag(original_question, vectorstore):
32
    # 生成回退问题
33
    step_back_q = generate_step_back_question(original_question)
34
    print(f"📝 回退问题: {step_back_q}")
35
    # 用回退问题检索
36
    docs = vectorstore.similarity_search(step_back_q, k=5)
37
    context = "\n\n".join([doc.page_content for doc in docs])
38
    # 最终回答
39
    final_prompt = f"""基于以下上下文信息，回答问题。
40

41
上下文：
42
{context}
43

44
回退问题：{step_back_q}
45
原问题：{original_question}
46

47
请给出准确、详细的回答："""
48
    response = llm.invoke(final_prompt)
49
    return response.content
50

51
#使用示例
52
question = "DeepSeek在2024年1月发布的模型性能如何？"
53
answer = step_back_rag(question, my_vectorstore)
54
print(f"✅ 答案: {answer}")