Problem in understanding Langchain SequentialChain with prompts and output_variables

[rmccorkl]

Dear all I'm Noob and not a good programmer, I have a semantic or logical error or maybe found an issue

I have a weird piece of behaviour which I find baffling it works in one scenario with what I think is incorrect coded but in workaround scenario I get what I expect. This can be simply explained as the chaining not working correctly (possible issue) or I'm missing some understanding.

But logically I just don't get it so any help would be appreciated the key line is the commented out line

    #output_variables=["ml_concept"],

If I leave commented the results is as expected I get a dumb down explanation, but if I uncomment the expert answer. It's as if the chains are not connected (inputs ouputs )both run without error but the results are different. My understanding says I should get the correct result with the code uncommented , I have the work around but what am I missing in my understanding ?

Any help would be appreciated

I have two prompts

from langchain import PromptTemplate
from langchain.chains import LLMChain

first_prompt=PromptTemplate.from_template(
    template="You are an expert in the field  of {field} explain the concept of {concept} in less than 100 words."
)
chain_one = LLMChain(llm=llm, prompt=first_prompt, output_key="ml_concept")

second_prompt=PromptTemplate.from_template(
    template="Take the following {ml_concept} and explain it to me like I'm a 5 year old child in 1000 words."
)

chain_two = LLMChain(llm=llm, prompt=second_prompt )
chatback = chain_one({'field':"Cardano",'concept':"Pov"})
print(chatback)

from langchain.chains import SequentialChain
overall_chain = SequentialChain(
    chains=[chain_one,chain_two],
    input_variables=["field","concept"],
    #output_variables=["ml_concept"],
    verbose=True)

explanation = overall_chain({'field':"Cardano",'concept':"PoV"})
print(explanation)

[dosubot[bot]]

Answer generated by a 🤖

Answer

Hello,

Thank you for reaching out and providing a detailed explanation of your issue. I understand that you're having trouble understanding the behavior of the SequentialChain when you uncomment the line output_variables=["ml_concept"].

The output_variables attribute in the SequentialChain class determines which variables are returned as output when the chain is run. When you uncomment the line output_variables=['ml_concept'], you are specifying that 'ml_concept' should be included in the output. If 'ml_concept' is not included in the "output_variables" list, it will not be included in the output, even if it is a key in the "known_values" dictionary. This is why the output differs when you uncomment this line.

In the context of the SequentialChain, the output_variables are used in two main ways:

1. Validation: In the validate_chains method, the output_variables are checked against the known variables (which are the union of input variables and memory variables). If there are any output_variables that are not in the known variables, a ValueError is raised indicating that there are expected output variables that were not found.

2. Output Generation: In the _call and _acall methods, the output_variables are used to select the relevant outputs from the known values after all chains have been processed. Only the values corresponding to the keys in output_variables are returned.

Here is the relevant code from the SequentialChain class:

def _call(
    self,
    inputs: Dict[str, str],
    run_manager: Optional[CallbackManagerForChainRun] = None,
) -> Dict[str, str]:
    ...
    return {k: known_values[k] for k in self.output_variables}

async def _acall(
    self,
    inputs: Dict[str, Any],
    run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
    ...
    return {k: known_values[k] for k in self.output_variables}

I hope this helps clarify the role of output_variables in the SequentialChain class and why uncommenting this line changes the output of your code. If you have any further questions, please don't hesitate to ask.

Best,
Dosu

Sources

• libs/langchain/langchain/chains/sequential.py
• docs/snippets/modules/chains/foundational/sequential_chains.mdx
• libs/langchain/tests/unit_tests/chains/test_sequential.py

---

This response is meant to be useful, save you time, and share context. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

[rmccorkl]

Should output_variables mirror the output_key ?

[rmccorkl]

Ahh so output_variables are used as memory variables ?

[dosubot[bot]]

Answer generated by a 🤖

Answer

Hello,

In the LangChain Python framework, the output_variables attribute in the SequentialChain class is used to specify which variables should be returned as output when the chain is run. It's a list of strings that represent the keys of the output data. After each chain in the sequence is executed, its output is added to a known_values dictionary. At the end of the sequence, a new dictionary is created that only includes the keys specified in output_variables from the known_values dictionary. This new dictionary is then returned as the final output of the SequentialChain.

The output_key attribute in the LLMChain class is used as the key for the output generated by the language model. It's used to store the parsed result of the language model's generation. By default, the output_key is set to "text".

The output_variables and output_key are not directly related. The output_key is specific to the LLMChain class and determines the key for the output of the language model, while output_variables is specific to the SequentialChain class and determines which keys from the known_values dictionary should be returned as output.

The memory attribute is used to store variables that can be used as inputs in subsequent chains. It's not directly related to output_variables or output_key, but it can affect which keys are available in the known_values dictionary, and therefore can affect which keys can be included in output_variables.

If you uncomment output_variables=["ml_concept"], it means that only the value associated with the key "ml_concept" in the known_values dictionary will be returned after all chains have been executed. If "ml_concept" is not a key in the known_values dictionary, a KeyError will be raised. This is why uncommenting output_variables=["ml_concept"] can change the output of the code.

I hope this clarifies your question. If you have any more questions, feel free to ask.

Best,
Dosu

Sources

• libs/langchain/langchain/chains/sequential.py
• docs/snippets/modules/chains/foundational/sequential_chains.mdx
• libs/langchain/langchain/chains/llm.py

---

This response is meant to be useful, save you time, and share context. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

[santiagovasquez1]

how doing the same but with lcel?

[dosubot[bot]]

To achieve the same functionality with LCEL instead of LangChain, you can follow these steps:

1. Define the prompts using PromptTemplate.
2. Chain the prompts with OpenAI and StrOutputParser.
3. Use RunnablePassthrough.assign to mimic the dict packaging of input and output.

Here is the equivalent code using LCEL:

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

# Define the first prompt
first_prompt = PromptTemplate.from_template(
    "You are an expert in the field of {field}. Explain the concept of {concept} in less than 100 words."
)

# Define the second prompt
second_prompt = PromptTemplate.from_template(
    "Take the following {ml_concept} and explain it to me like I'm a 5 year old child in 1000 words."
)

# Chain the first prompt with OpenAI and StrOutputParser
chain_one = first_prompt | OpenAI() | StrOutputParser()

# Chain the second prompt with OpenAI and StrOutputParser
chain_two = second_prompt | OpenAI() | StrOutputParser()

# Create an outer chain to package input and output
outer_chain = RunnablePassthrough().assign(ml_concept=chain_one).assign(final_output=chain_two)

# Invoke the outer chain with the input
result = outer_chain.invoke({"field": "Cardano", "concept": "PoV"})
print(result)

This will give you the same functionality as SequentialChain using LCEL. Additionally, LCEL supports first-class streaming, async support, and optimized parallel execution, making it a robust choice for both prototyping and production environments ^[1].

To continue talking to Dosu, mention @dosu.

[santiagovasquez1]

i have this code

def main(req: HttpRequest) -> HttpResponse:

history_aware_retriever_chain = create_history_aware_retriever(
    llm, retriever, contextualize_system_prompt()
)
combine_docs_chain = create_stuff_documents_chain(llm, qa_system_prompt())

summary_chain = summarize_system_chain(llm)

rag_chain: RunnableSerializable[Dict, Any] = create_retrieval_chain(
    history_aware_retriever_chain, combine_docs_chain)

full_chain = RunnablePassthrough().assign(
    system_message=rag_chain).assign(final_output=summary_chain)

query = req.params.get('name')
if not query:
    try:
        req_body = req.get_json()
    except ValueError:
        pass
    else:
        query = req_body.get('name')

if query:
    response = full_chain.invoke(
        {"input": query, "chat_history": history.messages})

i dont want use StrOutputParser() because i need the documents of the context, how apply assing to summary_chain if them prompt is this

def summarize_system_chain(llm: BaseLanguageModel):
template = "Create a summary with the main ideas of the following text:\n{system_message} Which was generated by a cognitive assistant."
prompt = ChatPromptTemplate.from_template(template)
chain = prompt | llm | StrOutputParser()
return chain

[santiagovasquez1]

i have the next code

import os
from typing import Any, Dict
import logging
from Helpers.set_gpts__helper import set_gpt_embeddings, set_gpt_llm
from azure.functions import HttpRequest, HttpResponse
from langchain_community.vectorstores.azuresearch import AzureSearch
from Helpers.set_env_helper import set_env
from langchain_core.language_models import BaseLanguageModel
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables import RunnableSerializable, RunnablePassthrough
from langchain.chains import create_retrieval_chain, LLMChain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.output_parsers import StrOutputParser
from langchain.chains import create_history_aware_retriever, SequentialChain
from langchain.output_parsers import JsonOutputKeyToolsParser

set_env()
history = ChatMessageHistory()
llm = set_gpt_llm(
    deployment=os.getenv("AZURE_CHAT_DEPLOYMENT"),
    api_version=os.getenv("AZURE_OPENAI_VERSION")
)

embeddings = set_gpt_embeddings(
    deployment=os.getenv("AZURE_EMBEDDINGS_DEPLOYMENT"),
    api_version=os.getenv("AZURE_OPENAI_VERSION")
)
index_name = os.getenv("AZURE_SEARCH_INDEX_NAME", "rag-azure-search")

vector_store_connection = AzureSearch(azure_search_endpoint=os.environ["AZURE_SEARCH_ENDPOINT"],
                                      azure_search_key=os.environ["AZURE_SEARCH_KEY"],
                                      index_name=index_name,
                                      embedding_function=embeddings.embed_query)

retriever = vector_store_connection.as_retriever(
    search_type="similarity", k=3, search_kwargs={"score_threshold": 0.7})


def main(req: HttpRequest) -> HttpResponse:

    history_aware_retriever_chain = create_history_aware_retriever(
        llm, retriever, contextualize_system_prompt()
    )
    combine_docs_chain = create_stuff_documents_chain(llm, qa_system_prompt())

    summary_chain = summarize_system_chain(llm)

    rag_chain: RunnableSerializable[Dict, Any] = create_retrieval_chain(
        history_aware_retriever_chain, combine_docs_chain)

    full_chain = RunnablePassthrough().assign(
        system_message=rag_chain).assign(summary=summary_chain)

    query = req.params.get('name')
    if not query:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            query = req_body.get('name')

    if query:
        response = full_chain.invoke(
            {"input": query, "chat_history": history.messages})
        # summary_response = summary_chain.invoke(response["answer"])
        history.add_user_message(query)
        history.add_ai_message(response["summary"])
        logging.info(response["system_message"]["answer"])
        return HttpResponse(response["system_message"]["answer"])
    else:
        return HttpResponse(
            "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.",
            status_code=200
        )


def summarize_system_chain(llm: BaseLanguageModel):
    template = "Create a summary with the main ideas of the following text:\n{system_message} Which was generated by a cognitive assistant."
    prompt = ChatPromptTemplate.from_template(template)
    chain = prompt | llm | StrOutputParser()
    return chain


def contextualize_system_prompt():
    template = """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. """

    return set_prompt(template)


def qa_system_prompt():
    template = """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. \
    keep the answer concise.\

    {context}"""
    return set_prompt(template)


def set_prompt(template: str):
    return ChatPromptTemplate.from_messages(
        [
            ("system", template),
            MessagesPlaceholder("chat_history"),
            ("human", "{input}"),
        ]
    )


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

i need pass the answer of rag_chain to summary_chain but i cant apply rag_chain | StrOutputParser() because i need the documents retrieve from rag_chain , how do that with lcel?

[santiagovasquez1]

@dosu