Request for Assistance with Splitting Tasks into Separate Agents and Creating an LangGraph Agentic Workflow

[mraguth]

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

tempalte "xxxxx"

template = template.format(dhead=df.head().to_markdown())

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", template),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
        ("human", "{input}"),
    ]
)

repl = PythonAstREPLTool(
    locals={"df": df},
    name="python_repl",
    description="Runs code and returns the output of the final line",
    args_schema=PythonInputs,
)
tools = [repl]
agent = OpenAIFunctionsAgent(llm=llm, prompt=prompt, tools=tools)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    max_iterations=10,
    early_stopping_method="generate",
    verbose=True,
    extra_tools=[retriever_tool],
) | (lambda x: x["output"])


# Typing for playground inputs
class AgentInputs(BaseModel):
    input: str

agent_executor = agent_executor.with_types(input_type=AgentInputs)


response = agent_executor.invoke({"input": output_query_str})     #### This may be need to be called in the langgraph
print(response)

import ast
import re
from langchain.agents.agent_toolkits import create_retriever_tool

####################### extra_tools or retriever_tool code #######################

# Function to execute a query and parse the results into a list of elements
def query_as_list(db, query):
    res = db.run(query)
    res = [el for sub in ast.literal_eval(res) for el in sub if el]
    res = [re.sub(r"\b\d+\b", "", string).strip() for string in res]
    return list(set(res))


# Create a vector store from the combined list of artists and albums
vector_db = FAISS.from_texts(names1, embeddings)
# Create a retriever from the vector store, retrieving the top 5 similar items
retriever = vector_db.as_retriever(search_kwargs={"k": 5})

# Description for the retriever tool
description = """Use to look up values to filter on. Input is an approximate spelling of the proper noun, output is \
valid proper nouns. Use the noun most similar to the search.
As an AI agent, you will be performing matching word cardinality. This involves comparing the number of times each word appears in two sets of text. You will count the occurrences of each word in both texts and determine the similarity based on these counts. Higher similarity indicates closer word usage patterns. This approach will help in tasks such as document comparison and plagiarism detection"""

# Create the retriever tool with the specified name and description
retriever_tool = create_retriever_tool(
    retriever,
    name="search_proper_nouns",
    description=description,
)

Description

I feel like I'm executing multiple tasks at the same time using the agent_executor in the code above. I really like the LangGraph agent concept because it’s cleaner and easier to understand. However, as a newcomer, I'm finding it challenging to understand the examples and apply them to my DataFrame situation.

Could you help me by showing how to separate my extra_tools or retriever_tool function into a dedicated agent and create an agentic workflow? My goal is for the extra_tools or retriever_tool agent to process the DataFrame (df) first, refine the data, and then pass it to the agent_executor, which will be assigned to another agent.

In essence, I want to break my large code into two agents and build a workflow where they work together. I would really appreciate some sample code to guide me.

Thank you!

System Info

Name: langchain
Version: 0.2.16

[dosubot[bot]]

I found two similar discussions that might be relevant to your question:

1. How I incorporate my Python_Pandas agent into workflow? ^[1]
2. Turn a DataFrame agent into a tool? ^[2]

To create an agentic workflow in LangChain where the extra_tools or retriever_tool agent processes the DataFrame (df) first, refines the data, and then passes it to the agent_executor, you can follow these steps:

Step 1: Define the Tools

from langchain.tools.retriever import create_retriever_tool
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# Load documents and create a retriever
loader = WebBaseLoader("https://docs.smith.langchain.com/overview")
docs = loader.load()
documents = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200).split_documents(docs)
vector = FAISS.from_documents(documents, OpenAIEmbeddings())
retriever = vector.as_retriever()

# Create retriever tool
retriever_tool = create_retriever_tool(
    retriever,
    "langsmith_search",
    "Search for information about LangSmith. For any questions about LangSmith, you must use this tool!",
)

Step 2: Create the First Agent

This agent will process the DataFrame.

from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent

# Initialize the language model
model = ChatOpenAI(model="gpt-4")

# Create the first agent with the retriever tool
tools = [retriever_tool]
agent1 = create_tool_calling_agent(model, tools)

Step 3: Create the Second Agent

This agent will execute further actions based on the refined data.

# Create the second agent (you can add more tools if needed)
agent2 = create_tool_calling_agent(model, tools)

Step 4: Combine Agents in a Workflow

Use AgentExecutor to manage the workflow.

from langchain.agents import AgentExecutor

# Create the first agent executor
agent_executor1 = AgentExecutor(agent=agent1, tools=tools)

# Create the second agent executor
agent_executor2 = AgentExecutor(agent=agent2, tools=tools)

# Define a function to process the DataFrame and pass it to the second agent
def process_and_execute(df):
    # Process the DataFrame with the first agent
    refined_data = agent_executor1.invoke({"input": df})
    
    # Pass the refined data to the second agent
    result = agent_executor2.invoke({"input": refined_data})
    
    return result

# Example usage
df = "Your DataFrame here"
result = process_and_execute(df)
print(result)

This setup ensures that the extra_tools or retriever_tool agent processes the DataFrame first, refines the data, and then passes it to the agent_executor, which is assigned to another agent ^[3].

To continue talking to Dosu, mention @dosu.

[mraguth]

@dosu I am getting missing 'prompt' error at creating agent1. Please hlep.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[22], [line 6](vscode-notebook-cell:?execution_count=22&line=6)
      [4](vscode-notebook-cell:?execution_count=22&line=4) # Create the first agent with the retriever tool
      [5](vscode-notebook-cell:?execution_count=22&line=5) tools = [retriever_tool]
----> [6](vscode-notebook-cell:?execution_count=22&line=6) agent1 = create_tool_calling_agent(llm, tools)

TypeError: create_tool_calling_agent() missing 1 required positional argument: 'prompt'

[dosubot[bot]]

To resolve the "missing 'prompt' error" when creating agent1 using create_tool_calling_agent, ensure that the prompt you pass to the function includes the required agent_scratchpad key. The agent_scratchpad key must be a MessagesPlaceholder.

Here is an example of how to correctly define the prompt:

from langchain.agents import create_tool_calling_agent, tool
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# Define the prompt
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a helpful assistant"),
        MessagesPlaceholder("chat_history", optional=True),
        ("human", "{input}"),
        MessagesPlaceholder("agent_scratchpad"),
    ]
)

# Initialize the language model
llm = ChatOpenAI(model="gpt-4")

# Define a tool (example)
@tool
def magic_function(input: int) -> int:
    """Applies a magic function to an input."""
    return input + 2

tools = [magic_function]

# Create the agent with the prompt
agent1 = create_tool_calling_agent(llm, tools, prompt)

Ensure that the prompt includes the agent_scratchpad key as shown above. This should resolve the "missing 'prompt' error" ^[1][2].

To continue talking to Dosu, mention @dosu.

[mraguth]

@dosu... looks great. Here I haven't seen langgraph concepts like nodes and edges and workflow. Is that possible to convert this example to langgraph concepts. I like to have a langgraph template if possible for the same scenario.

[dosubot[bot]]

Yes, it is possible to convert the given example to LangGraph concepts using nodes and edges to create a workflow. Below is a LangGraph template for the same scenario:

import pprint
from typing import Dict, TypedDict
from langchain_core.messages import BaseMessage
from langgraph.graph import END, StateGraph
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_chroma import Chroma
from langchain_community.document_loaders import WebBaseLoader
from langchain_openai import OpenAIEmbeddings
from langchainhub import hub
from langchain import ChatOpenAI, PromptTemplate, StrOutputParser
from pydantic import BaseModel, Field
from langchain.tools import convert_to_openai_tool, PydanticToolsParser

# Define the state
class GraphState(TypedDict):
    keys: Dict[str, any]

# Define the nodes
def retrieve(state):
    print("---RETRIEVE---")
    state_dict = state["keys"]
    question = state_dict["question"]
    documents = retriever.invoke(question)
    return {"keys": {"documents": documents, "question": question}}

def generate(state):
    print("---GENERATE---")
    state_dict = state["keys"]
    question = state_dict["question"]
    documents = state_dict["documents"]
    prompt = hub.pull("rlm/rag-prompt")
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    def format_docs(docs):
        return "\n\n".join(doc.page_content for doc in docs)
    rag_chain = prompt | llm | StrOutputParser()
    generation = rag_chain.invoke({"context": documents, "question": question})
    return {"keys": {"documents": documents, "question": question, "generation": generation}}

def grade_documents(state):
    print("---CHECK RELEVANCE---")
    state_dict = state["keys"]
    question = state_dict["question"]
    documents = state_dict["documents"]
    class grade(BaseModel):
        binary_score: str = Field(description="Relevance score 'yes' or 'no'")
    model = ChatOpenAI(temperature=0, model="gpt-4-0125-preview", streaming=True)
    grade_tool_oai = convert_to_openai_tool(grade)
    llm_with_tool = model.bind(tools=[convert_to_openai_tool(grade_tool_oai)], tool_choice={"type": "function", "function": {"name": "grade"}})
    parser_tool = PydanticToolsParser(tools=[grade])
    prompt = PromptTemplate(template="""You are a grader assessing relevance of a retrieved document to a user question. \n Here is the retrieved document: \n\n {context} \n\n Here is the user question: {question} \n If the document contains keyword(s) or semantic meaning related to the user question, grade it as relevant. \n Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question.""", input_variables=["context", "question"])
    chain = prompt | llm_with_tool | parser_tool
    filtered_docs = []
    search = "No"  # Default do not opt for web search to supplement retrieval
    for d in documents:
        score = chain.invoke({"question": question, "context": d.page_content})
        grade = score[0].binary_score
        if grade == "yes":
            print("---GRADE: DOCUMENT RELEVANT---")
            filtered_docs.append(d)
        else:
            print("---GRADE: DOCUMENT NOT RELEVANT---")
            search = "Yes"  # Perform web search
            continue
    return {"keys": {"documents": filtered_docs, "question": question, "run_web_search": search}}

def transform_query(state):
    print("---TRANSFORM QUERY---")
    state_dict = state["keys"]
    question = state_dict["question"]
    documents = state_dict["documents"]
    prompt = PromptTemplate(template="""You are generating questions that is well optimized for retrieval. \n Look at the input and try to reason about the underlying sematic intent / meaning. \n Here is the initial question: \n ------- \n {question} \n ------- \n Formulate an improved question: """, input_variables=["question"])
    model = ChatOpenAI(temperature=0, model="gpt-4-0125-preview", streaming=True)
    chain = prompt | model | StrOutputParser()
    better_question = chain.invoke({"question": question})
    return {"keys": {"documents": documents, "question": better_question}}

def web_search(state):
    print("---WEB SEARCH---")
    state_dict = state["keys"]
    question = state_dict["question"]
    documents = state_dict["documents"]
    tool = TavilySearchResults()
    docs = tool.invoke({"query": question})
    web_results = "\n".join([d["content"] for d in docs])
    web_results = Document(page_content=web_results)
    documents.append(web_results)
    return {"keys": {"documents": documents, "question": question}}

def decide_to_generate(state):
    print("---DECIDE TO GENERATE---")
    state_dict = state["keys"]
    question = state_dict["question"]
    filtered_documents = state_dict["documents"]
    search = state_dict["run_web_search"]
    if search == "Yes":
        print("---DECISION: TRANSFORM QUERY and RUN WEB SEARCH---")
        return "transform_query"
    else:
        print("---DECISION: GENERATE---")
        return "generate"

def grade_generation_v_documents(state):
    print("---GRADE GENERATION vs DOCUMENTS---")
    state_dict = state["keys"]
    question = state_dict["question"]
    documents = state_dict["documents"]
    generation = state_dict["generation"]
    class grade(BaseModel):
        binary_score: str = Field(description="Supported score 'yes' or 'no'")
    model = ChatOpenAI(temperature=0, model="gpt-4-0125-preview", streaming=True)
    grade_tool_oai = convert_to_openai_tool(grade)
    llm_with_tool = model.bind(tools=[convert_to_openai_tool(grade_tool_oai)], tool_choice={"type": "function", "function": {"name": "grade"}})
    parser_tool = PydanticToolsParser(tools=[grade])
    prompt = PromptTemplate(template="""You are a grader assessing whether an answer is grounded in / supported by a set of facts. \n Here are the facts: \n ------- \n {documents} \n ------- \n Here is the answer: {generation} Give a binary score 'yes' or 'no' to indicate whether the answer is grounded in / supported by a set of facts.""", input_variables=["generation", "documents"])
    chain = prompt | llm_with_tool | parser_tool
    score = chain.invoke({"generation": generation, "documents": documents})
    grade = score[0].binary_score
    if grade == "yes":
        print("---DECISION: SUPPORTED, MOVE TO FINAL GRADE---")
        return "supported"
    else:
        print("---DECISION: NOT SUPPORTED, GENERATE AGAIN---")
        return "not supported"

def grade_generation_v_question(state):
    print("---GRADE GENERATION vs QUESTION---")
    state_dict = state["keys"]
    question = state_dict["question"]
    documents = state_dict["documents"]
    generation = state_dict["generation"]
    class grade(BaseModel):
        binary_score: str = Field(description="Useful score 'yes' or 'no'")
    model = ChatOpenAI(temperature=0, model="gpt-4-0125-preview", streaming=True)
    grade_tool_oai = convert_to_openai_tool(grade)
    llm_with_tool = model.bind(tools=[convert_to_openai_tool(grade_tool_oai)], tool_choice={"type": "function", "function": {"name": "grade"}})
    parser_tool = PydanticToolsParser(tools=[grade])
    prompt = PromptTemplate(template="""You are a grader assessing whether an answer is useful to resolve a question. \n Here is the answer: \n ------- \n {generation} \n ------- \n Here is the question: {question} Give a binary score 'yes' or 'no' to indicate whether the answer is useful to resolve a question.""", input_variables=["generation", "question"])
    chain = prompt | llm_with_tool | parser_tool
    score = chain.invoke({"generation": generation, "question": question})
    grade = score[0].binary_score
    if grade == "yes":
        print("---DECISION: USEFUL---")
        return "useful"
    else:
        print("---DECISION: NOT USEFUL---")
        return "not useful"

# Build the graph
workflow = StateGraph(GraphState)
workflow.add_node("retrieve", retrieve)
workflow.add_node("grade_documents", grade_documents)
workflow.add_node("generate", generate)
workflow.add_node("transform_query", transform_query)
workflow.add_node("web_search", web_search)
workflow.add_node("prepare_for_final_grade", lambda state: state)  # passthrough

workflow.set_entry_point("retrieve")
workflow.add_edge("retrieve", "grade_documents")
workflow.add_conditional_edges("grade_documents", decide_to_generate, {"transform_query": "transform_query", "generate": "generate"})
workflow.add_edge("transform_query", "web_search")
workflow.add_edge("web_search", "generate")
workflow.add_conditional_edges("generate", grade_generation_v_documents, {"supported": "prepare_for_final_grade", "not supported": "generate"})
workflow.add_conditional_edges("prepare_for_final_grade", grade_generation_v_question, {"useful": END, "not useful": "transform_query"})

# Compile the graph
app = workflow.compile()

# Run the graph
inputs = {"keys": {"question": "Explain how the different types of agent memory work?"}}
for output in app.stream(inputs):
    for key, value in output.items():
        pprint.pprint(f"Output from node '{key}':")
        pprint.pprint("---")
        pprint.pprint(value["keys"], indent=2, width=80, depth=None)
    pprint.pprint("\n---\n")

inputs = {"keys": {"question": "Explain how chain of thought prompting works?"}}
for output in app.stream(inputs):
    for key, value in output.items():
        pprint.pprint(f"Output from node '{key}':")
        pprint.pprint("---")
        pprint.pprint(value["keys"], indent=2, width=80, depth=None)
    pprint.pprint("\n---\n")

This template sets up the nodes and edges to create a workflow using LangGraph, following the Corrective-RAG (CRAG) process described in the document. The LangGraph implementation allows for the incorporation of tool calling and other features, making it a robust solution for analyzing and processing documents ^[1][2][3].

To continue talking to Dosu, mention @dosu.

[mraguth]

@dosu This is good template. But how I convert this to input = pandas dataframe? I mean my input should be restricted to internal 'pandas dataframe'....any thoughts?

inputs = {"keys": {"question": "Explain how the different types of agent memory work?"}} #### These questions could be answered based on my pandas dataframe.

[dosubot[bot]]

To convert the LangGraph template to use a pandas DataFrame as input instead of a question string, you can follow these steps:

1. Load the CSV into a pandas DataFrame:

   import pandas as pd
   
   df = pd.read_csv("your_dataframe.csv")

2. Modify the nodes to interact with the DataFrame:

   Update the nodes to process the DataFrame. For example, you can create a node that performs operations on the DataFrame and returns the result.

   def process_dataframe(state):
       print("---PROCESS DATAFRAME---")
       state_dict = state["keys"]
       df = state_dict["dataframe"]
       # Example operation: Calculate the correlation between 'age' and 'fare'
       correlation = df[['age', 'fare']].corr().iloc[0, 1]
       return {"keys": {"dataframe": df, "correlation": correlation}}

3. Update the workflow to include the new node:

   Add the new node to the workflow and set it as the entry point.

   # Build the graph
   workflow = StateGraph(GraphState)
   workflow.add_node("process_dataframe", process_dataframe)
   workflow.add_node("retrieve", retrieve)
   workflow.add_node("grade_documents", grade_documents)
   workflow.add_node("generate", generate)
   workflow.add_node("transform_query", transform_query)
   workflow.add_node("web_search", web_search)
   workflow.add_node("prepare_for_final_grade", lambda state: state)  # passthrough
   
   workflow.set_entry_point("process_dataframe")
   workflow.add_edge("process_dataframe", "retrieve")
   workflow.add_edge("retrieve", "grade_documents")
   workflow.add_conditional_edges("grade_documents", decide_to_generate, {"transform_query": "transform_query", "generate": "generate"})
   workflow.add_edge("transform_query", "web_search")
   workflow.add_edge("web_search", "generate")
   workflow.add_conditional_edges("generate", grade_generation_v_documents, {"supported": "prepare_for_final_grade", "not supported": "generate"})
   workflow.add_conditional_edges("prepare_for_final_grade", grade_generation_v_question, {"useful": END, "not useful": "transform_query"})

4. Compile and run the graph with the DataFrame as input:

   Pass the DataFrame as input to the workflow.

   # Compile the graph
   app = workflow.compile()
   
   # Run the graph
   inputs = {"keys": {"dataframe": df}}
   for output in app.stream(inputs):
       for key, value in output.items():
           pprint.pprint(f"Output from node '{key}':")
           pprint.pprint("---")
           pprint.pprint(value["keys"], indent=2, width=80, depth=None)
       pprint.pprint("\n---\n")

By following these steps, you can convert the LangGraph template to use a pandas DataFrame as input and process it within the workflow.

To continue talking to Dosu, mention @dosu.

[mraguth]

@dosu... in the below function, where I ask my question? plaese help... the function you have given is below...:

I used to ask a question like this in the past :

response = agent_executor.invoke({"input": output_query_str})     #### This may be need to be called in the langgraph
print(response)

Funciton you have given:::::

from langchain.agents import AgentExecutor

# Create the first agent executor
agent_executor1 = AgentExecutor(agent=agent1, tools=tools)

# Create the second agent executor
agent_executor2 = AgentExecutor(agent=agent2, tools=tools)

# Define a function to process the DataFrame and pass it to the second agent
def process_and_execute(df):
    # Process the DataFrame with the first agent
    refined_data = agent_executor1.invoke({"input": df})
    
    # Pass the refined data to the second agent
    result = agent_executor2.invoke({"input": refined_data})
    
    return result

# Example usage
df = "Your DataFrame here"
result = process_and_execute(df)
print(result)

[dosubot[bot]]

To ask a question using the process_and_execute function, you need to modify the function to accept both the DataFrame and the question string as inputs. Here is how you can do it:

1. Modify the process_and_execute function to accept a question string:

   from langchain.agents import AgentExecutor
   
   # Create the first agent executor
   agent_executor1 = AgentExecutor(agent=agent1, tools=tools)
   
   # Create the second agent executor
   agent_executor2 = AgentExecutor(agent=agent2, tools=tools)
   
   # Define a function to process the DataFrame and pass it to the second agent
   def process_and_execute(df, question):
       # Process the DataFrame with the first agent
       refined_data = agent_executor1.invoke({"input": df})
       
       # Pass the refined data and the question to the second agent
       result = agent_executor2.invoke({"input": question, "refined_data": refined_data})
       
       return result
   
   # Example usage
   df = pd.read_csv("your_dataframe.csv")
   question = "What is the correlation between age and fare?"
   result = process_and_execute(df, question)
   print(result)

2. Ensure the agents are set up to handle the inputs correctly:

   Make sure that agent1 and agent2 are designed to process the DataFrame and the question respectively. For example, agent1 should refine the DataFrame, and agent2 should use the refined data to answer the question.

3. Update the prompt for agent2 to include the refined data:

   Ensure that the prompt for agent2 is set up to handle both the question and the refined data.

   from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
   
   # Define the prompt for agent2
   prompt2 = ChatPromptTemplate.from_messages(
       [
           ("system", "You are a helpful assistant that uses refined data to answer questions."),
           MessagesPlaceholder("chat_history", optional=True),
           ("human", "{input}"),
           MessagesPlaceholder("agent_scratchpad"),
       ]
   )
   
   # Create agent2 with the updated prompt
   agent2 = create_tool_calling_agent(llm, tools, prompt2)

By following these steps, you can ask a question using the process_and_execute function, where the DataFrame is processed first, and then the question is answered using the refined data.

To continue talking to Dosu, mention @dosu.

[mraguth]

@dosu... thank you it is working. Is that possible for me to extend the same concept for agent3 and agent4 etc? Thoughts?

[dosubot[bot]]

Yes, it is possible to extend the same concept for agent3 and agent4. The DirectorDialogueAgent class is designed to handle multiple agents, and the DialogueSimulator can manage the conversation flow among them. You can add additional agents (agent3 and agent4) in the same way as the existing agents.

Here is how you can extend the concept to include agent3 and agent4:

# Define additional agents
additional_agents = [
    ("Agent3", "Role3", "Location3"),
    ("Agent4", "Role4", "Location4"),
]

# Generate descriptions, headers, and system messages for the additional agents
additional_agent_descriptions = [
    generate_agent_description(name, role, location)
    for name, role, location in additional_agents
]
additional_agent_headers = [
    generate_agent_header(name, role, location, description)
    for (name, role, location), description in zip(additional_agents, additional_agent_descriptions)
]
additional_agent_system_messages = [
    generate_agent_system_message(name, header)
    for name, header in zip([name for name, _, _ in additional_agents], additional_agent_headers)
]

# Create DialogueAgent instances for the additional agents
for name, system_message in zip(
    [name for name, _, _ in additional_agents], additional_agent_system_messages
):
    agents.append(
        DialogueAgent(
            name=name,
            system_message=system_message,
            model=ChatOpenAI(temperature=0.2),
        )
    )

# Update the simulator with the new agents
simulator = DialogueSimulator(
    agents=agents,
    selection_function=functools.partial(select_next_speaker, director=director),
)
simulator.reset()
simulator.inject("Audience member", specified_topic)
print(f"(Audience member): {specified_topic}")
print("\n")

while True:
    name, message = simulator.step()
    print(f"({name}): {message}")
    print("\n")
    if director.stop:
        break

This code snippet shows how to define additional agents, generate their descriptions, headers, and system messages, create DialogueAgent instances for them, and update the simulator to include these new agents ^[1].

To continue talking to Dosu, mention @dosu.

[mraguth]

@dosu... Love it...thank you.

[dosubot[bot]]

You're welcome! I'm glad to hear it's working for you. If you have any more questions or need further assistance, feel free to ask. Happy coding!

To continue talking to Dosu, mention @dosu.