Is there a parallel edge in langgraph allowing to execute two indipendents nodes at the same time?

[davlu93]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

def build_graph() -> StateGraph:

    graph = StateGraph(GraphState)

    graph.add_node("trim_chat_history", trim_chat_history_node)
    graph.add_node("contextualize_question", contextualize_question_node)
    graph.add_node("retriever", retriever_node)
    graph.add_node("generate_answer", generate_answer_node)
    graph.add_node("generate_answer_no_rag", generate_answer_no_rag_node)
    graph.add_node("shop", shopping_node)

   
    graph.add_conditional_edges(
        "trim_chat_history",
        rag_no_rag_decision_edge,
        {
            "NO_rag":"generate_answer_no_rag",
            "RAG":"contextualize_question"
        },
    )
    graph.add_edge("contextualize_question", "retriever")

    graph.add_edge("generate_answer_no_rag", "shop")
    graph.add_edge("retriever", "generate_answer")
    graph.add_edge("generate_answer", "shop")
    graph.add_edge("shop", END)
    # graph.add_edge("generate_answer", END)

    graph.set_entry_point("trim_chat_history")

    return graph

Description

I'd like to have something like a parallel edge with two nodes. This would allow to execute the two nodes in parallel at the same time, without waiting one node to finish

System Info

langchain==0.1.13
langchain-chroma==0.1.0
langchain-cli==0.0.21
langchain-community==0.0.29
langchain-core==0.1.50
langchain-google-genai==0.0.9
langchain-google-vertexai==0.1.1
langchain-groq==0.1.3
langchain-mistralai==0.0.5
langchain-mongodb==0.1.1
langchain-openai==0.1.0
langchain-text-splitters==0.0.1

[dosubot[bot]]

Yes, you can create a parallel edge in LangGraph to execute two independent nodes at the same time using the RunnableParallel primitive. This allows you to run multiple runnables in parallel and return their outputs as a map.

Here is an example of how to use RunnableParallel to execute two independent nodes in parallel:

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableParallel
from langchain_openai import ChatOpenAI

model = ChatOpenAI()
joke_chain = ChatPromptTemplate.from_template("tell me a joke about {topic}") | model
poem_chain = ChatPromptTemplate.from_template("write a 2-line poem about {topic}") | model

map_chain = RunnableParallel(joke=joke_chain, poem=poem_chain)

map_chain.invoke({"topic": "bear"})

In this example, joke_chain and poem_chain are executed in parallel, and the results are returned in a map with keys "joke" and "poem" ^[1].

Additionally, LangGraph provides a more detailed structure for managing nodes and edges, including support for conditional edges and various node types. You can define nodes and edges using the Node and Edge classes, and manage them within a Graph object. This allows for more complex graph-based workflows beyond simple parallel execution ^[2].

Details

About Dosu
This response is meant to be useful and save you time. 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.

To continue the conversation, mention @dosu.

[Freezaa9]

Also interested :)

Edit: Did this answer your question ? https://langchain-ai.github.io/langgraph/how-tos/branching/

[bedead]

As of current langgraph documentation, there is no seperate parallel edge method. But langgraph does provide a way to call two independent nodes branching off from one node or two in some cases.

To do that u can follow this

# if calling in between graph
graph.add_edge("node_1", "node_2")
graph.add_edge("node_1", "node_3")

# if calling from start of graph 
graph.add_edge(START, "node_1")
graph.add_edge(START, "node_2")

# this will spawn two thread running parallel

Also while doing something similar, the state should be edited as well to handle the state changes. For example if node_1 and node_2 both make changes to same attribute in graph state, then u must handle it (could be by appending the values from each node) properly so that the values don't override each other.

If u have any other questions related to topic, I am open to discuss.