#-------------------------------Prepare Vector Database----------------------# Build a sample vectorDBfrom langchain.text_splitter import RecursiveCharacterTextSplitterfrom langchain_community.document_loaders import WebBaseLoaderfrom langchain_community.vectorstores import Chromafrom langchain.embeddings import OpenAIEmbeddingsimport os
os.environ["OPENAI_API_KEY"] = "Your Open AI KEY"
# Load blog postloader = WebBaseLoader("https://lilianweng.github.io/posts/2023-06-23-agent/")data = loader.load()
# Splittext_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=0)splits = text_splitter.split_documents(data)
# VectorDBembedding = OpenAIEmbeddings()vectordb = Chroma.from_documents(documents=splits, embedding=embedding)
#---------------------------Prepare Multi Query Retriever--------------------from langchain.retrievers.multi_query import MultiQueryRetrieverfrom langchain.chat_models import ChatOpenAI
question = "What are the approaches to Task Decomposition?"llm = ChatOpenAI(temperature=0)retriever_from_llm = MultiQueryRetriever.from_llm(retriever=vectordb.as_retriever(), llm=llm)
#----------------------Setup QnA----------------------------------------from langchain_core.output_parsers import StrOutputParserfrom langchain_core.runnables import RunnablePassthroughfrom langchain_core.prompts import ChatPromptTemplate

qa_system_prompt = """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. \
{context}"""
qa_prompt = ChatPromptTemplate.from_messages([("system", qa_system_prompt),("human", "{question}"),])
def format_docs(docs):doc_strings = [doc.page_content for doc in docs]return "\n\n".join(doc_strings)

rag_chain = ({"context": retriever_from_llm | format_docs, "question": RunnablePassthrough()}| qa_prompt| llm| StrOutputParser())
rag_chain.invoke("What are the approaches to Task Decomposition?")

There are three approaches to task decomposition:
1. LLM with simple prompting: This approach involves using a language model like GPT-3 to generate step-by-step instructions for a given task. The model can be prompted with a simple instruction like "Steps for XYZ" and it will generate a list of subgoals or steps to achieve the task.
2. Task-specific instructions: This approach involves providing task-specific instructions to guide the decomposition process. For example, if the task is to write a novel, the instruction could be "Write a story outline." This approach helps to provide more specific guidance and structure to the decomposition process.
3. Human inputs: This approach involves involving human inputs in the task decomposition process. Humans can provide their expertise and knowledge to break down a complex task into smaller, more manageable subtasks. This approach can be useful when dealing with tasks that require domain-specific knowledge or expertise.
These approaches can be used individually or in combination depending on the nature of the task and the available resources.

#-------------------------------Prepare Vector Database----------------------# Build a sample vectorDBfrom langchain.text_splitter import RecursiveCharacterTextSplitterfrom langchain_community.document_loaders import WebBaseLoaderfrom langchain_community.vectorstores import Chromafrom langchain.embeddings import OpenAIEmbeddingsimport os
os.environ["OPENAI_API_KEY"] = "Your Open AI KEY"
# Load blog postloader = WebBaseLoader("https://lilianweng.github.io/posts/2023-06-23-agent/")data = loader.load()
# Splittext_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=0)splits = text_splitter.split_documents(data)
# VectorDBembedding = OpenAIEmbeddings()vectordb = Chroma.from_documents(documents=splits, embedding=embedding)
#--------------------------------QnA Part and Reordering------------------------------------from langchain.chat_models import ChatOpenAIfrom langchain_core.output_parsers import StrOutputParserfrom langchain_core.runnables import RunnablePassthroughfrom langchain_core.prompts import ChatPromptTemplatefrom langchain_community.document_transformers import (LongContextReorder,)
llm = ChatOpenAI()
qa_system_prompt = """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. \
{context}"""
qa_prompt = ChatPromptTemplate.from_messages([("system", qa_system_prompt),("human", "{question}"),])
def format_docs(docs):#Called the reordering function in herereordering = LongContextReorder()reordered_docs = reordering.transform_documents(docs)doc_strings = [doc.page_content for doc in reordered_docs]return "\n\n".join(doc_strings)

rag_chain = ({"context": vectordb.as_retriever() | format_docs, "question": RunnablePassthrough()}| qa_prompt| llm| StrOutputParser())rag_chain.invoke("What are the approaches to Task Decomposition?")

There are three approaches to task decomposition:
1. LLM with simple prompting: This approach involves using simple prompts to guide the agent in breaking down a task into smaller subgoals. For example, the agent can be prompted with "Steps for XYZ" or "What are the subgoals for achieving XYZ?" This approach relies on the language model's ability to generate appropriate subgoals based on the given prompts.
2. Task-specific instructions: In this approach, task decomposition is done by providing task-specific instructions to the agent. For example, if the task is to write a novel, the agent can be instructed to "Write a story outline." This approach provides more specific guidance to the agent in decomposing the task.
3. Human inputs: Task decomposition can also be done with the help of human inputs. This approach involves receiving input or guidance from a human to break down the task into smaller subgoals. The human input can be in the form of instructions, suggestions, or feedback provided to the agent.

#-------------------------------Prepare Vector Database----------------------# Build a sample vectorDBfrom langchain.text_splitter import RecursiveCharacterTextSplitterfrom langchain_community.document_loaders import WebBaseLoaderfrom langchain_community.vectorstores import Chromafrom langchain.embeddings import OpenAIEmbeddingsimport os
os.environ["OPENAI_API_KEY"] = "Your Open AI API KEY"
# Load blog postloader = WebBaseLoader("https://lilianweng.github.io/posts/2023-06-23-agent/")data = loader.load()
# Splittext_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)splits = text_splitter.split_documents(data)
# VectorDBembedding = OpenAIEmbeddings()vectordb = Chroma.from_documents(documents=splits, embedding=embedding)
#----------------------------Contextual Compression Setup---------------------from langchain.retrievers.document_compressors import DocumentCompressorPipeline, EmbeddingsFilterfrom langchain.text_splitter import CharacterTextSplitterfrom langchain_community.document_transformers import EmbeddingsRedundantFilterfrom langchain.retrievers import ContextualCompressionRetriever
splitter = CharacterTextSplitter(chunk_size=300, chunk_overlap=0, separator=". ")redundant_filter = EmbeddingsRedundantFilter(embeddings=embedding)relevant_filter = EmbeddingsFilter(embeddings=embedding, similarity_threshold=0.76)pipeline_compressor = DocumentCompressorPipeline(transformers=[splitter, redundant_filter, relevant_filter])
compression_retriever = ContextualCompressionRetriever(base_compressor=pipeline_compressor, base_retriever=vectordb.as_retriever())
#--------------------------------QnA Part------------------------------------from langchain.chat_models import ChatOpenAIfrom langchain_core.output_parsers import StrOutputParserfrom langchain_core.runnables import RunnablePassthroughfrom langchain_core.prompts import ChatPromptTemplate
llm = ChatOpenAI()
qa_system_prompt = """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. \
{context}"""
qa_prompt = ChatPromptTemplate.from_messages([("system", qa_system_prompt),("human", "{question}"),])
def format_docs(docs):doc_strings = [doc.page_content for doc in docs]return "\n\n".join(doc_strings)

rag_chain = ({"context": compression_retriever | format_docs, "question": RunnablePassthrough()}| qa_prompt| llm| StrOutputParser())
rag_chain.invoke("What are the approaches to Task Decomposition?")

There are several approaches to task decomposition:
1. LLM with simple prompting: This approach involves using a large language model (LLM) like OpenAI's GPT-3 to decompose tasks. By providing simple prompts such as "Steps for XYZ" or "What are the subgoals for achieving XYZ?", the LLM can generate a list of subgoals or steps necessary to complete the task.
2. Task-specific instructions: In this approach, task decomposition is guided by providing specific instructions tailored to the task at hand. For example, if the task is to write a novel, the instruction could be "Write a story outline." This helps the agent break down the task into smaller components and focus on each step individually.
3. Human inputs: Task decomposition can also be done with the help of human inputs. Humans can provide guidance, expertise, and domain-specific knowledge to assist in breaking down complex tasks into manageable subgoals. This approach leverages the problem-solving abilities and intuition of humans to aid in the decomposition process.
It's important to note that these approaches can be used in combination or separately, depending on the specific requirements and constraints of the task.