Understanding LangChain Graphs

Oct 13, 2025 by wbrum.org 1 views

LangChain is a powerful library for building AI applications, and one of its key features is the ability to create and visualize complex graphs. In this article, we will explore how to get the whole graph in LangChain, including creating individual component visualizations and a simplified hierarchy view.

Understanding LangChain Graphs

Before we dive into the code, it's essential to understand what LangChain graphs are and how they work. LangChain graphs are a way to represent complex relationships between different components, such as agents, tools, and workflows. These graphs can be visualized using various tools and libraries, including Mermaid and Graphviz.

Creating Individual Component Visualizations

To create individual component visualizations, we can use the visualize_langgraph function, which takes a LangGraph object and an output file name as arguments. This function uses the get_graph method to retrieve the graph object and then uses the draw_mermaid_png method to generate a PNG image of the graph.

Here's an example of how to create individual component visualizations:

# Generate individual component visualizations
print("Generating individual component visualizations...")
visualize_langgraph(app, "workflow_graph.png")
visualize_langgraph(research_team, "research_team_graph.png")
visualize_langgraph(creating_team, "creating_team_graph.png")
if top_level_supervisor:
    visualize_langgraph(top_level_supervisor, "supervisor_graph.png")

Creating a Simplified Hierarchy View

To create a simplified hierarchy view, we can use the create_simplified_hierarchy function, which takes an output file name as an argument. This function uses Mermaid to generate a simplified hierarchy diagram that shows the relationships between components.

Here's an example of how to create a simplified hierarchy view:

# Generate a simplified hierarchy view
print("\nGenerating simplified hierarchy view...")
create_simplified_hierarchy("agent_hierarchy.png")

Code Explanation

The code provided is a comprehensive example of how to create individual component visualizations and a simplified hierarchy view in LangChain. Here's a breakdown of the key components:

visualize_langgraph function: This function takes a LangGraph object and an output file name as arguments and uses the get_graph method to retrieve the graph object and then uses the draw_mermaid_png method to generate a PNG image of the graph.
create_simplified_hierarchy function: This function takes an output file name as an argument and uses Mermaid to generate a simplified hierarchy diagram that shows the relationships between components.
create_mermaid_chart function: This function takes Mermaid code and an output file name as arguments and uses the Mermaid Live Editor API to generate a Mermaid chart.

Conclusion

In this article, we explored how to get the whole graph in LangChain, including creating individual component visualizations and a simplified hierarchy view. We also provided a comprehensive example of how to use the visualize_langgraph and create_simplified_hierarchy functions to create these visualizations.

By following the code examples and explanations provided, you should be able to create your own LangChain graphs and visualize them using individual component visualizations and simplified hierarchy views.

Code

# Import necessary libraries
from langgraph.prebuilt import create_react_agent
from langgraph_supervisor import create_supervisor
from langchain_openai import ChatOpenAI

# Create a ChatOpenAI model
model = ChatOpenAI(model="gpt-4o", openai_api_key="sk-BlbkFJu_9YDOnot real kzaBP2g-zWWSIcxaxCnG4-BmeIA")

# Define a web search function
def web_search(query: str) -> str:
    """Search the web for information."""
    return (
        "web research results"
    )

# Define a docs search function
def docs_search(path: str) -> str:
    """Search the local docs for information."""
    return (
        "docs research results"
    )

# Create a web research agent
web_research_agent = create_react_agent(
    model=model,
    tools=[web_search],
    name="web_research_expert",
    prompt="You are a world class web researcher with access to web search."
)

# Create a docs research agent
docs_research_agent = create_react_agent(
    model=model,
    tools=[docs_search],
    name="docs_research_expert",
    prompt="You are a world class local documents researcher with access to web search."
)

# Create a research team
research_team = create_supervisor(
    [web_research_agent, docs_research_agent],
    model=model,
).compile(name="research_team")

# Create a writing agent
writing_agent = create_react_agent(
    model=model,
    tools=[],  # tools to help writing
    name="writing_expert",
    prompt="You are a world class writing expert."
)

# Create a reviewing agent
reviewing_agent = create_react_agent(
    model=model,
    tools=[],  # tools to help reviewing
    name="reviewing_expert",
    prompt="You are a world class reviewing expert."
)

# Create a creating team
creating_team = create_supervisor(
    [writing_agent, reviewing_agent],
    model=model,
).compile(name="creating_team")

# Create a top-level supervisor
top_level_supervisor = create_supervisor(
    [research_team, creating_team],
    model=model,
).compile(name="top_level_supervisor")

# Create a workflow
workflow = create_supervisor(
    agents=[research_team, creating_team],
    model=model,
    output_mode="full_history",
    prompt=(
        "You are a team supervisor managing a research team and content creating team"
    )
)

# Compile the workflow
app = workflow.compile()

# Define a function to visualize a LangGraph component
def visualize_langgraph(graph_obj, output_file="graph.png"):
    """Visualize a single LangGraph component"""
    try:
        # Get PNG data directly using draw_mermaid_png
        png_data = graph_obj.get_graph().draw_mermaid_png()

        # Save to file
        with open(output_file, "wb") as f:
            f.write(png_data)
        print(f"Graph saved as '{output_file}'")

        # Open the image
        os.startfile(os.path.abspath(output_file))
        return True
    except Exception as e:
        print(f"Error visualizing graph: {e}")
        return False

# Define a function to create a simplified hierarchy view
def create_simplified_hierarchy(output_file="hierarchy_view.png"):
    """Create a simplified hierarchy diagram showing relationships between components"""
    # Create a simpler Mermaid diagram that's less likely to cause errors
    hierarchy_diagram = """
flowchart TD
    %% Main components
    Workflow[Main Workflow]
    ResearchTeam[Research Team]
    CreatingTeam[Creating Team]

    %% Sub-components
    WebResearch[Web Research Agent]
    DocsResearch[Docs Research Agent]
    Writing[Writing Agent]
    Reviewing[Reviewing Agent]

    %% Relationships
    Workflow --> ResearchTeam
    Workflow --> CreatingTeam
    ResearchTeam --> WebResearch
    ResearchTeam --> DocsResearch
    CreatingTeam --> Writing
    CreatingTeam --> Reviewing

    %% Data flow
    WebResearch -- "Research Data" --> Writing
    DocsResearch -- "Documentation" --> Writing
    Writing -- "Draft Content" --> Reviewing

    %% Styles
    classDef workflow fill:#e1bee7,stroke:#8e24aa,stroke-width:3px;
    classDef team fill:#ffcc80,stroke:#ef6c00,stroke-width:2px;
    classDef agent fill:#81c784,stroke:#2e7d32,stroke-width:1px;

    class Workflow workflow;
    class ResearchTeam,CreatingTeam team;
    class WebResearch,DocsResearch,Writing,Reviewing agent;
"""
    # Create the visualization using an online service
    try:
        create_mermaid_chart(hierarchy_diagram, output_file)
        return True
    except Exception as e:
        print(f"Error creating hierarchy view: {e}")
        return False

# Define a function to create a Mermaid chart
def create_mermaid_chart(mermaid_code, output_file="flowchart.png"):
    """Create a Mermaid chart using the Mermaid Live Editor API."""
    print(f"Rendering Mermaid chart for {output_file}...")

    try:
        # Create the JSON state object
        state_json = {
            "code": mermaid_code,
            "mermaid": {"theme": "default"},
            "updateEditor": True
        }

        # Convert to JSON and encode to base64
        state_str = json.dumps(state_json)
        encoded_state = base64.urlsafe_b64encode(state_str.encode('utf-8')).decode('utf-8')

        # Create the URL with proper headers
        url = f"https://mermaid.ink/img/{encoded_state}"

        # Create a request with a user agent
        req = urllib.request.Request(
            url,
            headers={
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
            }
        )

        # Download the image with proper headers
        with urllib.request.urlopen(req) as response, open(output_file, 'wb') as out_file:
            out_file.write(response.read())
        print(f"Chart saved as '{output_file}'")

        # Open the image file with the default viewer
        os.startfile(os.path<br/>
**Q&A: Getting the Whole Graph in LangChain**
=============================================

In our previous article, we explored how to get the whole graph in LangChain, including creating individual component visualizations and a simplified hierarchy view. Here, we'll answer some frequently asked questions about LangChain graphs and visualizations.

**Q: What is a LangChain graph?**
------------------------------

A LangChain graph is a way to represent complex relationships between different components, such as agents, tools, and workflows. These graphs can be visualized using various tools and libraries, including Mermaid and Graphviz.

**Q: How do I create a LangChain graph?**
--------------------------------------

To create a LangChain graph, you can use the `create_supervisor` function to create a supervisor that manages a team of agents. You can then use the `compile` method to compile the supervisor and create a graph object.

**Q: How do I visualize a LangChain graph?**
--------------------------------------------

To visualize a LangChain graph, you can use the `visualize_langgraph` function, which takes a LangGraph object and an output file name as arguments. This function uses the `get_graph` method to retrieve the graph object and then uses the `draw_mermaid_png` method to generate a PNG image of the graph.

**Q: What is a simplified hierarchy view?**
---------------------------------------------

A simplified hierarchy view is a way to visualize the relationships between components in a LangChain graph. It shows the main components, sub-components, and relationships between them.

**Q: How do I create a simplified hierarchy view?**
------------------------------------------------

To create a simplified hierarchy view, you can use the `create_simplified_hierarchy` function, which takes an output file name as an argument. This function uses Mermaid to generate a simplified hierarchy diagram that shows the relationships between components.

**Q: What is Mermaid?**
----------------------

Mermaid is a JavaScript library for creating diagrams and flowcharts. It can be used to generate a wide range of diagrams, including flowcharts, sequence diagrams, and Gantt charts.

**Q: How do I use Mermaid to generate a diagram?**
------------------------------------------------

To use Mermaid to generate a diagram, you can create a Mermaid code string that describes the diagram you want to create. You can then use the `create_mermaid_chart` function to generate the diagram and save it to a file.

**Q: What are some common use cases for LangChain graphs?**
------------------------------------------------------

LangChain graphs can be used in a wide range of applications, including:

*   **Workflow management**: LangChain graphs can be used to visualize and manage complex workflows, including those that involve multiple agents and tools.
*   **Team management**: LangChain graphs can be used to visualize and manage teams of agents, including those that involve multiple roles and responsibilities.
*   **Knowledge management**: LangChain graphs can be used to visualize and manage knowledge graphs, including those that involve multiple concepts and relationships.

**Q: What are some best practices for working with LangChain graphs?**
-------------------------------------------------------------------

Here are some best practices for working with LangChain graphs:

*   **Use clear and concise naming conventions**: Use clear and concise naming conventions for your agents, tools, and workflows to make it easy to understand and work with your LangChain graph.
*   **Use a consistent layout**: Use a consistent layout for your LangChain graph to make it easy to understand and navigate.
*   **Use visualizations to communicate complex information**: Use visualizations to communicate complex information and make it easy to understand and work with your LangChain graph.

**Conclusion**
----------

In this article, we've answered some frequently asked questions about LangChain graphs and visualizations. We've also provided some best practices for working with LangChain graphs and visualizations. By following these best practices and using the techniques and tools described in this article, you can create effective and efficient LangChain graphs and visualizations that help you manage complex workflows and teams.