构建一个检索增强生成(RAG)应用 #

1pip install -Uq langchain langchain-community langchain-chroma

1pip install python-dotenv

1from dotenv import load_dotenv
2assert load_dotenv()
3
4import os
5MODEL_NAME = os.environ.get("MODEL_NAME")
6EMBEDDING_MODEL_NAME = os.environ.get("EMBEDDING_MODEL_NAME")

1pip install -qU langchain-openai

1from langchain_openai import ChatOpenAI
2llm = ChatOpenAI(model=MODEL_NAME)

1pip install beautifulsoup4

 1import bs4
 2from langchain import hub
 3from langchain_chroma import Chroma
 4from langchain_community.document_loaders import WebBaseLoader
 5from langchain_core.output_parsers import StrOutputParser
 6from langchain_core.runnables import RunnablePassthrough
 7from langchain_openai import OpenAIEmbeddings
 8from langchain_text_splitters import RecursiveCharacterTextSplitter
 9
10# Load, chunk and index the contents of the blog.
11loader = WebBaseLoader(
12    web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
13    bs_kwargs=dict(
14        parse_only=bs4.SoupStrainer(
15            class_=("post-content", "post-title", "post-header")
16        )
17    )
18    
19)
20docs = loader.load()
21
22text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
23splits = text_splitter.split_documents(docs)
24vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings(model=EMBEDDING_MODEL_NAME))
25
26# Retrieve and generate using the relevant snippets of the blog.
27retriever = vectorstore.as_retriever()
28prompt = hub.pull("rlm/rag-prompt")
29print(prompt)
30
31def format_docs(docs):
32    return "\n\n".join(doc.page_content for doc in docs)
33
34rag_chain = (
35    {"context": retriever | format_docs, "question": RunnablePassthrough()}
36    | prompt
37    | llm
38    | StrOutputParser()
39)
40
41rag_chain.invoke("What is Task Decomposition?")

1'Task Decomposition is a process where a complex task is broken down into smaller, simpler steps or subtasks. This technique is utilized to enhance model performance on complex tasks by making them more manageable. It can be done by using language models with simple prompting, task-specific instructions, or with human inputs.'

 1import bs4
 2from langchain_community.document_loaders import WebBaseLoader
 3
 4# Only keep post title, headers, and content from the full HTML.
 5bs4_strainer = bs4.SoupStrainer(class_=("post-title", "post-header", "post-content"))
 6loader = WebBaseLoader(
 7    web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
 8    bs_kwargs={"parse_only": bs4_strainer},
 9)
10docs = loader.load()
11
12len(docs[0].page_content)

143131

1print(docs[0].page_content[:500])

1 LLM Powered Autonomous Agents
2    
3Date: June 23, 2023  |  Estimated Reading Time: 31 min  |  Author: Lilian Weng
4
5
6Building agents with LLM (large language model) as its core controller is a cool concept. Several proof-of-concepts demos, such as AutoGPT, GPT-Engineer and BabyAGI, serve as inspiring examples. The potentiality of LLM extends beyond generating well-written copies, stories, essays and programs; it can be framed as a powerful general problem solver.
7Agent System Overview#
8In

1from langchain_text_splitters import RecursiveCharacterTextSplitter
2
3text_splitter = RecursiveCharacterTextSplitter(
4    chunk_size=1000, chunk_overlap=200, add_start_index=True
5)
6all_splits = text_splitter.split_documents(docs)
7
8len(all_splits)

166

1len(all_splits[0].page_content)

1969

1all_splits[10].metadata

1{'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/',
2 'start_index': 7056}

1from langchain_chroma import Chroma
2from langchain_openai import OpenAIEmbeddings
3
4vectorstore = Chroma.from_documents(documents=all_splits, embedding=OpenAIEmbeddings(model=EMBEDDING_MODEL_NAME))

1retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 6})
2
3retrieved_docs = retriever.invoke("What are the approaches to Task Decomposition?")
4
5len(retrieved_docs)

16

1print(retrieved_docs[0].page_content)

1Tree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.
2Task decomposition can be done (1) by LLM with simple prompting like "Steps for XYZ.\n1.", "What are the subgoals for achieving XYZ?", (2) by using task-specific instructions; e.g. "Write a story outline." for writing a novel, or (3) with human inputs.

1pip install -qU langchain-openai

1from langchain_openai import ChatOpenAI
2llm = ChatOpenAI(model=MODEL_NAME)

1from langchain import hub
2
3prompt = hub.pull("rlm/rag-prompt")
4
5example_messages = prompt.invoke(
6    {"context": "filler context", "question": "filler question"}
7).to_messages()
8
9example_messages

1[HumanMessage(content="You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.\nQuestion: filler question \nContext: filler context \nAnswer:")]

1print(example_messages[0].content)

1You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.
2Question: filler question 
3Context: filler context 
4Answer:

 1from langchain_core.output_parsers import StrOutputParser
 2from langchain_core.runnables import RunnablePassthrough
 3
 4
 5def format_docs(docs):
 6    return "\n\n".join(doc.page_content for doc in docs)
 7
 8
 9rag_chain = (
10    {"context": retriever | format_docs, "question": RunnablePassthrough()}
11    | prompt
12    | llm
13    | StrOutputParser()
14)
15
16for chunk in rag_chain.stream("What is Task Decomposition?"):
17    print(chunk, end="", flush=True)

1Task decomposition involves breaking down a complex task into smaller, manageable steps to facilitate problem-solving. This can be achieved using large language models (LLMs) through simple prompts, task-specific instructions, or human inputs. The process enhances the model's performance by allowing it to tackle each step systematically.

1chain = (
2    {"context": retriever | format_docs, "question": RunnablePassthrough()}
3    | prompt
4)

 1from langchain.chains import create_retrieval_chain
 2from langchain.chains.combine_documents import create_stuff_documents_chain
 3from langchain_core.prompts import ChatPromptTemplate
 4
 5system_prompt = (
 6    "You are an assistant for question-answering tasks. "
 7    "Use the following pieces of retrieved context to answer "
 8    "the question. If you don't know the answer, say that you "
 9    "don't know. Use three sentences maximum and keep the "
10    "answer concise."
11    "\n\n"
12    "{context}"
13)
14
15prompt = ChatPromptTemplate.from_messages(
16    [
17        ("system", system_prompt),
18        ("human", "{input}"),
19    ]
20)
21
22
23question_answer_chain = create_stuff_documents_chain(llm, prompt)
24rag_chain = create_retrieval_chain(retriever, question_answer_chain)
25
26response = rag_chain.invoke({"input": "What is Task Decomposition?"})
27print(response["answer"])

1Task decomposition is the process of breaking down a complicated task into smaller, manageable steps or subgoals. It can be achieved using various methods, such as prompting a language model, giving task-specific instructions, or incorporating human inputs. This approach enhances understanding and efficiency in problem-solving.

1for document in response["context"]:
2    print(document)
3    print()

 1page_content='Fig. 1. Overview of a LLM-powered autonomous agent system.\nComponent One: Planning#\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\nTask Decomposition#\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.' metadata={'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
 2
 3page_content='Fig. 1. Overview of a LLM-powered autonomous agent system.\nComponent One: Planning#\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\nTask Decomposition#\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.' metadata={'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/', 'start_index': 1585}
 4
 5page_content='Tree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\nTask decomposition can be done (1) by LLM with simple prompting like "Steps for XYZ.\\n1.", "What are the subgoals for achieving XYZ?", (2) by using task-specific instructions; e.g. "Write a story outline." for writing a novel, or (3) with human inputs.' metadata={'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/', 'start_index': 2192}
 6
 7page_content='Tree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\nTask decomposition can be done (1) by LLM with simple prompting like "Steps for XYZ.\\n1.", "What are the subgoals for achieving XYZ?", (2) by using task-specific instructions; e.g. "Write a story outline." for writing a novel, or (3) with human inputs.' metadata={'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
 8
 9page_content='Resources:\n1. Internet access for searches and information gathering.\n2. Long Term memory management.\n3. GPT-3.5 powered Agents for delegation of simple tasks.\n4. File output.\n\nPerformance Evaluation:\n1. Continuously review and analyze your actions to ensure you are performing to the best of your abilities.\n2. Constructively self-criticize your big-picture behavior constantly.\n3. Reflect on past decisions and strategies to refine your approach.\n4. Every command has a cost, so be smart and efficient. Aim to complete tasks in the least number of steps.' metadata={'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/'}
10
11page_content='Resources:\n1. Internet access for searches and information gathering.\n2. Long Term memory management.\n3. GPT-3.5 powered Agents for delegation of simple tasks.\n4. File output.\n\nPerformance Evaluation:\n1. Continuously review and analyze your actions to ensure you are performing to the best of your abilities.\n2. Constructively self-criticize your big-picture behavior constantly.\n3. Reflect on past decisions and strategies to refine your approach.\n4. Every command has a cost, so be smart and efficient. Aim to complete tasks in the least number of steps.' metadata={'source': 'https://lilianweng.github.io/posts/2023-06-23-agent/', 'start_index': 29630}

 1from langchain_core.prompts import PromptTemplate
 2
 3template = """Use the following pieces of context to answer the question at the end.
 4If you don't know the answer, just say that you don't know, don't try to make up an answer.
 5Use three sentences maximum and keep the answer as concise as possible.
 6Always say "thanks for asking!" at the end of the answer.
 7
 8{context}
 9
10Question: {question}
11
12Helpful Answer:"""
13custom_rag_prompt = PromptTemplate.from_template(template)
14
15rag_chain = (
16    {"context": retriever | format_docs, "question": RunnablePassthrough()}
17    | custom_rag_prompt
18    | llm
19    | StrOutputParser()
20)
21
22rag_chain.invoke("What is Task Decomposition?")

1'Task Decomposition is the process of breaking down a complex task into smaller, manageable steps or subgoals. This can be achieved through various methods, such as prompting a language model, using task-specific instructions, or providing human inputs. It helps enhance performance by allowing a systematic approach to solving difficult problems. Thanks for asking!'