Logging Standalone Queries Created in RAG with Memory

[shalini0311]

I’m currently using Retrieval-Augmented Generation (RAG) with memory, and the code is working well. However, I’d like to log the standalone queries created using the chat history and current query.

I’m looking for guidance on how to capture and log these standalone queries effectively.

Here’s the code I’m working with:

import bs4
from langchain.chains import create_history_aware_retriever, create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_chroma import Chroma
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_community.document_loaders import WebBaseLoader
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)


### Construct retriever ###
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())
retriever = vectorstore.as_retriever()


### Contextualize question ###
contextualize_q_system_prompt = (
    "Given a chat history and the latest user question "
    "which might reference context in the chat history, "
    "formulate a standalone question which can be understood "
    "without the chat history. Do NOT answer the question, "
    "just reformulate it if needed and otherwise return it as is."
)
contextualize_q_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", contextualize_q_system_prompt),
        MessagesPlaceholder("chat_history"),
        ("human", "{input}"),
    ]
)
history_aware_retriever = create_history_aware_retriever(
    llm, retriever, contextualize_q_prompt
)


### Answer question ###
system_prompt = (
    "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, say that you "
    "don't know. Use three sentences maximum and keep the "
    "answer concise."
    "\n\n"
    "{context}"
)
qa_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", system_prompt),
        MessagesPlaceholder("chat_history"),
        ("human", "{input}"),
    ]
)
question_answer_chain = create_stuff_documents_chain(llm, qa_prompt)

rag_chain = create_retrieval_chain(history_aware_retriever, question_answer_chain)


### Statefully manage chat history ###
store = {}


def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]


conversational_rag_chain = RunnableWithMessageHistory(
    rag_chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="chat_history",
    output_messages_key="answer",
)

answer = conversational_rag_chain.invoke(
       {"input": query}
)

### Logic required here ---> Some way to get standalone query created above here?

Any help or suggestions on how to achieve this would be greatly appreciated!

Thank you!

[dosubot[bot]]

Hey @shalini0311! I'm here to help you with any bugs, questions, or code contributions. Let's tackle this together!

To capture and log the standalone queries created using the chat history and the current query in your Retrieval-Augmented Generation (RAG) system, you can modify your setup to return the generated standalone question. Here's how you can achieve this:

1. Modify the RAG Chain to Return the Generated Question: You need to configure the rag_chain to return the generated standalone question. This can be done by setting the return_generated_question attribute to True.

2. Log the Generated Standalone Question: Once the chain is configured to return the generated question, you can access it from the result and log it.

Here's how you can implement these changes in your code:

# Set the chain to return the generated question
rag_chain.return_generated_question = True

# Invoke the chain with a query and chat history
chat_history = []  # Collect chat history here (a sequence of messages)
result = conversational_rag_chain.invoke({"input": query, "chat_history": chat_history})

# Log the generated standalone question
generated_question = result.get("generated_question")
print("Generated Standalone Question:", generated_question)

By setting return_generated_question to True, the RAG chain will include the generated standalone question in its output, allowing you to log it effectively ^[1].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[shalini0311]

Hi @dosu,

I tried implementing the modifications as suggested, but it doesn't seem to work as expected. I'm encountering the following error:

ValueError: "RunnableBinding" object has no field "return_generated_question"

Additionally, I attempted the following approach:

create_retrieval_chain(
    retriever=history_aware_retriever,
    combine_docs_chain=question_answer_chain,
    return_generated_question=True  # Add this line to return the generated question
)

This also throws the following error:
create_retrieval_chain() got an unexpected keyword argument 'return_generated_question'

It seems that I’m missing something when trying to log the generated questions. Could anyone help me understand why these errors are happening or suggest a proper solution for logging the standalone queries created during the process?

Thanks in advance for your assistance!

[dosubot[bot]]

The errors you're encountering are due to the fact that the create_retrieval_chain function and the RunnableBinding object do not have a return_generated_question attribute or parameter. To log the standalone queries, you need to modify the chain to capture and return the intermediate output explicitly.

Here's a revised approach to achieve this:

1. Modify the Chain to Capture the Standalone Question: You can create a custom chain or modify the existing one to include the standalone question as part of the output.

2. Access and Log the Standalone Question: Once the chain is configured to return the standalone question, you can access it from the result and log it.

Here's an example of how you can implement these changes:

from langchain.chains.base import Chain

class CustomRAGChain(Chain):
    @property
    def input_keys(self) -> List[str]:
        return ["input", "chat_history"]

    @property
    def output_keys(self) -> List[str]:
        return ["answer", "generated_question"]

    def _call(self, inputs: Dict[str, Any], run_manager: Optional[CallbackManagerForChainRun] = None) -> Dict[str, Any]:
        # Use the existing RAG chain logic to get the answer
        result = self.rag_chain.invoke(inputs)
        
        # Extract the generated standalone question
        generated_question = result.get("generated_question", "No question generated")
        
        # Return both the answer and the generated question
        return {
            "answer": result["answer"],
            "generated_question": generated_question
        }

# Instantiate your custom chain
custom_rag_chain = CustomRAGChain(rag_chain=conversational_rag_chain)

# Invoke the custom chain
result = custom_rag_chain.invoke({"input": query, "chat_history": []})

# Log the generated standalone question
print("Generated Standalone Question:", result["generated_question"])

This approach involves creating a custom chain that extends the existing chain's functionality to include the standalone question in the output. This way, you can effectively log the standalone queries created during the process.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[shalini0311]

Hi @dosu,

Please assist me in integrating with the existing code.

This is the current code:

import bs4
from langchain.chains import create_history_aware_retriever, create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_chroma import Chroma
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_community.document_loaders import WebBaseLoader
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)


### Construct retriever ###
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())
retriever = vectorstore.as_retriever()


### Contextualize question ###
contextualize_q_system_prompt = (
    "Given a chat history and the latest user question "
    "which might reference context in the chat history, "
    "formulate a standalone question which can be understood "
    "without the chat history. Do NOT answer the question, "
    "just reformulate it if needed and otherwise return it as is."
)
contextualize_q_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", contextualize_q_system_prompt),
        MessagesPlaceholder("chat_history"),
        ("human", "{input}"),
    ]
)
history_aware_retriever = create_history_aware_retriever(
    llm, retriever, contextualize_q_prompt
)


### Answer question ###
system_prompt = (
    "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, say that you "
    "don't know. Use three sentences maximum and keep the "
    "answer concise."
    "\n\n"
    "{context}"
)
qa_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", system_prompt),
        MessagesPlaceholder("chat_history"),
        ("human", "{input}"),
    ]
)
question_answer_chain = create_stuff_documents_chain(llm, qa_prompt)

rag_chain = create_retrieval_chain(history_aware_retriever, question_answer_chain)


### Statefully manage chat history ###
store = {}


def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]


conversational_rag_chain = RunnableWithMessageHistory(
    rag_chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="chat_history",
    output_messages_key="answer",
)

answer = conversational_rag_chain.invoke(
       {"input": query}
)

### Logic required here ---> Some way to get standalone query created above here?

[dosubot[bot]]

To capture and log the standalone queries created in your existing Retrieval-Augmented Generation (RAG) setup, you can modify the create_history_aware_retriever function to return the standalone question. Here's how you can integrate this into your current code:

1. Modify the create_history_aware_retriever function: Adjust the function to return the standalone question along with the retrieved documents.

2. Access and log the standalone question: Once the function is modified, you can access the standalone question from the result and log it.

Here's an example of how you can implement these changes:

from langchain.chains.base import Chain

class CustomHistoryAwareRetriever(Chain):
    def __init__(self, llm, retriever, prompt):
        self.llm = llm
        self.retriever = retriever
        self.prompt = prompt

    @property
    def input_keys(self) -> List[str]:
        return ["input", "chat_history"]

    @property
    def output_keys(self) -> List[str]:
        return ["retrieved_documents", "generated_question"]

    def _call(self, inputs: Dict[str, Any], run_manager: Optional[CallbackManagerForChainRun] = None) -> Dict[str, Any]:
        # Generate the standalone question
        standalone_question = self.prompt.format_messages(inputs)
        
        # Retrieve documents using the standalone question
        retrieved_documents = self.retriever.retrieve(standalone_question)
        
        # Return both the retrieved documents and the standalone question
        return {
            "retrieved_documents": retrieved_documents,
            "generated_question": standalone_question
        }

# Instantiate your custom retriever
custom_history_aware_retriever = CustomHistoryAwareRetriever(llm, retriever, contextualize_q_prompt)

# Use the custom retriever in your RAG chain
rag_chain = create_retrieval_chain(custom_history_aware_retriever, question_answer_chain)

# Invoke the chain
result = conversational_rag_chain.invoke({"input": query, "chat_history": []})

# Log the generated standalone question
print("Generated Standalone Question:", result["generated_question"])

This approach involves creating a custom retriever that extends the existing functionality to include the standalone question in the output. This way, you can effectively log the standalone queries created during the process.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[shalini0311]

Hi @dosu,

I followed your suggestion, but I’m now encountering a new issue. I’m getting the following error:
ValueError: "CustomHistoryAwareRetriever" object has no field "llm"

Has anyone else faced a similar issue or can point me in the right direction to fix this?
Any advice would be appreciated.

[dosubot[bot]]

The error you're encountering suggests that the CustomHistoryAwareRetriever class is not properly initializing or storing the llm attribute. To fix this, ensure that the __init__ method of your custom class correctly initializes all necessary attributes. Here's how you can adjust the class definition:

from langchain.chains.base import Chain
from typing import List, Dict, Any, Optional

class CustomHistoryAwareRetriever(Chain):
    def __init__(self, llm, retriever, prompt):
        super().__init__()  # Ensure the base class is initialized
        self.llm = llm
        self.retriever = retriever
        self.prompt = prompt

    @property
    def input_keys(self) -> List[str]:
        return ["input", "chat_history"]

    @property
    def output_keys(self) -> List[str]:
        return ["retrieved_documents", "generated_question"]

    def _call(self, inputs: Dict[str, Any], run_manager: Optional[CallbackManagerForChainRun] = None) -> Dict[str, Any]:
        # Generate the standalone question
        standalone_question = self.prompt.format_messages(**inputs)
        
        # Retrieve documents using the standalone question
        retrieved_documents = self.retriever.retrieve(standalone_question)
        
        # Return both the retrieved documents and the standalone question
        return {
            "retrieved_documents": retrieved_documents,
            "generated_question": standalone_question
        }

# Instantiate your custom retriever
custom_history_aware_retriever = CustomHistoryAwareRetriever(llm, retriever, contextualize_q_prompt)

# Use the custom retriever in your RAG chain
rag_chain = create_retrieval_chain(custom_history_aware_retriever, question_answer_chain)

# Invoke the chain
result = conversational_rag_chain.invoke({"input": query, "chat_history": []})

# Log the generated standalone question
print("Generated Standalone Question:", result["generated_question"])

Make sure that the super().__init__() call is included in the __init__ method to properly initialize the base class. This should resolve the issue with the llm attribute not being recognized.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[shalini0311]

Hi @dosu, I’m still encountering the same error.

[dosubot[bot]]

Ensure that the CustomHistoryAwareRetriever class is correctly initialized and that all necessary attributes are properly set. Here's a refined version of the class to help address the issue:

from langchain.chains.base import Chain
from typing import List, Dict, Any, Optional

class CustomHistoryAwareRetriever(Chain):
    def __init__(self, llm, retriever, prompt):
        super().__init__()  # Initialize the base class
        self.llm = llm
        self.retriever = retriever
        self.prompt = prompt

    @property
    def input_keys(self) -> List[str]:
        return ["input", "chat_history"]

    @property
    def output_keys(self) -> List[str]:
        return ["retrieved_documents", "generated_question"]

    def _call(self, inputs: Dict[str, Any], run_manager: Optional[CallbackManagerForChainRun] = None) -> Dict[str, Any]:
        # Generate the standalone question
        standalone_question = self.prompt.format_messages(**inputs)
        
        # Retrieve documents using the standalone question
        retrieved_documents = self.retriever.retrieve(standalone_question)
        
        # Return both the retrieved documents and the standalone question
        return {
            "retrieved_documents": retrieved_documents,
            "generated_question": standalone_question
        }

# Instantiate your custom retriever
custom_history_aware_retriever = CustomHistoryAwareRetriever(llm, retriever, contextualize_q_prompt)

# Use the custom retriever in your RAG chain
rag_chain = create_retrieval_chain(custom_history_aware_retriever, question_answer_chain)

# Invoke the chain
result = conversational_rag_chain.invoke({"input": query, "chat_history": []})

# Log the generated standalone question
print("Generated Standalone Question:", result["generated_question"])

Make sure that the llm, retriever, and prompt are correctly passed to the CustomHistoryAwareRetriever when you instantiate it. If the error persists, double-check that these variables are properly defined and initialized before being used in the class.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[shalini0311]

@dosu, Yes I cross checked, I'm still getting the same error.
Here is my code:

import bs4
from langchain.chains import create_history_aware_retriever, create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_chroma import Chroma
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_community.document_loaders import WebBaseLoader
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain.chains.base import Chain
from typing import List, Dict, Any, Optional
from langchain_core.callbacks.manager import CallbackManagerForChainRun

class CustomHistoryAwareRetriever(Chain):
    def __init__(self, llm, retriever, prompt):
        super().__init__()  # Initialize the base class
        self.llm = llm
        self.retriever = retriever
        self.prompt = prompt

    @property
    def input_keys(self) -> List[str]:
        return ["input", "chat_history"]

    @property
    def output_keys(self) -> List[str]:
        return ["retrieved_documents", "generated_question"]

    def _call(self, inputs: Dict[str, Any], run_manager: Optional[CallbackManagerForChainRun] = None) -> Dict[str, Any]:
        # Generate the standalone question
        standalone_question = self.prompt.format_messages(**inputs)
        
        # Retrieve documents using the standalone question
        retrieved_documents = self.retriever.retrieve(standalone_question)
        
        # Return both the retrieved documents and the standalone question
        return {
            "retrieved_documents": retrieved_documents,
            "generated_question": standalone_question
        }

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)


### Construct retriever ###
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())
retriever = vectorstore.as_retriever()


### Contextualize question ###
contextualize_q_system_prompt = (
    "Given a chat history and the latest user question "
    "which might reference context in the chat history, "
    "formulate a standalone question which can be understood "
    "without the chat history. Do NOT answer the question, "
    "just reformulate it if needed and otherwise return it as is."
)
contextualize_q_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", contextualize_q_system_prompt),
        MessagesPlaceholder("chat_history"),
        ("human", "{input}"),
    ]
)
custom_history_aware_retriever = CustomHistoryAwareRetriever(
    llm, retriever, contextualize_q_prompt
)


### Answer question ###
system_prompt = (
    "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, say that you "
    "don't know. Use three sentences maximum and keep the "
    "answer concise."
    "\n\n"
    "{context}"
)
qa_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", system_prompt),
        MessagesPlaceholder("chat_history"),
        ("human", "{input}"),
    ]
)
question_answer_chain = create_stuff_documents_chain(llm, qa_prompt)

rag_chain = create_retrieval_chain(custom_history_aware_retriever, question_answer_chain)


### Statefully manage chat history ###
store = {}


def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]


conversational_rag_chain = RunnableWithMessageHistory(
    rag_chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="chat_history",
    output_messages_key="answer",
)

answer = conversational_rag_chain.invoke(
       {"input": query}
)

[dosubot[bot]]

To resolve the "ValueError: 'CustomHistoryAwareRetriever' object has no field 'llm'" error, ensure that the llm attribute is correctly initialized and used within your CustomHistoryAwareRetriever class. The error suggests that the llm attribute is not being recognized, which might be due to how it's being accessed or initialized.

Here's a refined version of your class to ensure proper initialization and usage:

from langchain.chains.base import Chain
from typing import List, Dict, Any, Optional
from langchain_core.callbacks.manager import CallbackManagerForChainRun

class CustomHistoryAwareRetriever(Chain):
    def __init__(self, llm, retriever, prompt):
        super().__init__()  # Initialize the base class
        self.llm = llm
        self.retriever = retriever
        self.prompt = prompt

    @property
    def input_keys(self) -> List[str]:
        return ["input", "chat_history"]

    @property
    def output_keys(self) -> List[str]:
        return ["retrieved_documents", "generated_question"]

    def _call(self, inputs: Dict[str, Any], run_manager: Optional[CallbackManagerForChainRun] = None) -> Dict[str, Any]:
        # Generate the standalone question
        standalone_question = self.prompt.format_messages(**inputs)
        
        # Retrieve documents using the standalone question
        retrieved_documents = self.retriever.retrieve(standalone_question)
        
        # Return both the retrieved documents and the standalone question
        return {
            "retrieved_documents": retrieved_documents,
            "generated_question": standalone_question
        }

# Ensure that the llm, retriever, and prompt are correctly instantiated
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

# Instantiate your custom retriever
custom_history_aware_retriever = CustomHistoryAwareRetriever(
    llm, retriever, contextualize_q_prompt
)

# Use the custom retriever in your RAG chain
rag_chain = create_retrieval_chain(custom_history_aware_retriever, question_answer_chain)

# Invoke the chain
result = conversational_rag_chain.invoke({"input": query, "chat_history": []})

# Log the generated standalone question
print("Generated Standalone Question:", result["generated_question"])

Make sure that the llm, retriever, and prompt are correctly passed to the CustomHistoryAwareRetriever when you instantiate it. Double-check that these variables are properly defined and initialized before being used in the class. If the error persists, verify that the llm object is correctly instantiated and compatible with the expected interface ^[1].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[shalini0311]

@dosu, it's correctly passed as per the code you shared.
Still getting the same error.

[dosubot[bot]]

To address the persistent error regarding the llm attribute, let's ensure that the CustomHistoryAwareRetriever class is correctly handling the language model (llm) and that all components are properly integrated. Here's a step-by-step approach to troubleshoot and resolve the issue:

1. Ensure Proper Initialization: Double-check that the llm is correctly instantiated before being passed to the CustomHistoryAwareRetriever. The ChatOpenAI instance should be created without issues.

2. Verify Attribute Access: Ensure that the llm attribute is being accessed correctly within the class. If the error persists, it might be due to how the attribute is being used or accessed.

3. Check for Typographical Errors: Ensure there are no typographical errors in the attribute names or method calls.

Here's a refined version of the class and its usage:

from langchain.chains.base import Chain
from typing import List, Dict, Any, Optional
from langchain_core.callbacks.manager import CallbackManagerForChainRun

class CustomHistoryAwareRetriever(Chain):
    def __init__(self, llm, retriever, prompt):
        super().__init__()  # Initialize the base class
        self.llm = llm
        self.retriever = retriever
        self.prompt = prompt

    @property
    def input_keys(self) -> List[str]:
        return ["input", "chat_history"]

    @property
    def output_keys(self) -> List[str]:
        return ["retrieved_documents", "generated_question"]

    def _call(self, inputs: Dict[str, Any], run_manager: Optional[CallbackManagerForChainRun] = None) -> Dict[str, Any]:
        # Generate the standalone question
        standalone_question = self.prompt.format_messages(**inputs)
        
        # Retrieve documents using the standalone question
        retrieved_documents = self.retriever.retrieve(standalone_question)
        
        # Return both the retrieved documents and the standalone question
        return {
            "retrieved_documents": retrieved_documents,
            "generated_question": standalone_question
        }

# Ensure that the llm, retriever, and prompt are correctly instantiated
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

# Instantiate your custom retriever
custom_history_aware_retriever = CustomHistoryAwareRetriever(
    llm, retriever, contextualize_q_prompt
)

# Use the custom retriever in your RAG chain
rag_chain = create_retrieval_chain(custom_history_aware_retriever, question_answer_chain)

# Invoke the chain
result = conversational_rag_chain.invoke({"input": query, "chat_history": []})

# Log the generated standalone question
print("Generated Standalone Question:", result["generated_question"])

If the error persists, consider adding debug print statements to verify that the llm, retriever, and prompt are correctly initialized and passed to the class. This can help identify where the issue might be occurring. Additionally, ensure that all dependencies and imports are correctly set up and that there are no conflicts with other parts of the code.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[shalini0311]

I'm still getting this error. Can someone suggest a solution for this?
@sbusso , @jarib , @zeke , @deepblue

[sbusso]

@Shalini031 no random mention please