Request for Sequential Messaging and Response Collection

[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

https://python.langchain.com/v0.2/docs/integrations/retrievers/tavily/

The code I am using...
import datetime

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableConfig, chain

today = datetime.datetime.today().strftime("%D")
prompt = ChatPromptTemplate(
    [
        ("system", f"You are a helpful assistant. The date today is {today}."),
        ("human", "{user_input}"),
        ("placeholder", "{messages}"),
    ]
)

# specifying tool_choice will force the model to call this tool.
llm_with_tools = llm.bind_tools([tool])

llm_chain = prompt | llm_with_tools


@chain
def tool_chain(user_input: str, config: RunnableConfig):
    input_ = {"user_input": user_input}
    ai_msg = llm_chain.invoke(input_, config=config)
    tool_msgs = tool.batch(ai_msg.tool_calls, config=config)
    return llm_chain.invoke({**input_, "messages": [ai_msg, *tool_msgs]}, config=config)


response = tool_chain.invoke("""Give me one latest news on Apple Stock""")

Description

I need to send 25+ separate messages to Tavily and collect a response for each one. Is it possible to send these messages sequentially? While the examples provided are simplified, real-life scenarios are more complex. Could you provide a sample code to illustrate how this can be done?

System Info

Name: langchain
Version: 0.2.16

[dosubot[bot]]

To send multiple messages sequentially and collect responses for each one, you can iterate over your list of messages and invoke the tool_chain for each message. Below is an example of how you can achieve this:

import datetime
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableConfig, chain

# Define the current date
today = datetime.datetime.today().strftime("%D")

# Define the prompt template
prompt = ChatPromptTemplate(
    [
        ("system", f"You are a helpful assistant. The date today is {today}."),
        ("human", "{user_input}"),
        ("placeholder", "{messages}"),
    ]
)

# Bind tools to the language model
llm_with_tools = llm.bind_tools([tool])

# Create the LLM chain
llm_chain = prompt | llm_with_tools

# Define the tool chain
@chain
def tool_chain(user_input: str, config: RunnableConfig):
    input_ = {"user_input": user_input}
    ai_msg = llm_chain.invoke(input_, config=config)
    tool_msgs = tool.batch(ai_msg.tool_calls, config=config)
    return llm_chain.invoke({**input_, "messages": [ai_msg, *tool_msgs]}, config=config)

# List of messages to send
messages = [
    "Give me one latest news on Apple Stock",
    "What is the weather like in New York?",
    "Tell me a joke",
    # Add more messages as needed
]

# Configuration for the Runnable
config = RunnableConfig(
    tags=["example"],
    metadata={"source": "user_request"},
    callbacks=None,
    run_name="sequential_message_run",
    max_concurrency=1,
    recursion_limit=25,
    configurable={},
    run_id=None
)

# Collect responses for each message
responses = []
for message in messages:
    response = tool_chain.invoke(message, config=config)
    responses.append(response)

# Print the collected responses
for i, response in enumerate(responses):
    print(f"Response {i+1}: {response}")

In this example:

1. We define a list of messages to send.
2. We iterate over each message, invoking the tool_chain for each one.
3. We collect the responses in a list and print them out.

This approach ensures that each message is processed sequentially, and you can handle more complex scenarios by adjusting the tool_chain and RunnableConfig as needed.

To continue talking to Dosu, mention @dosu.

[mraguth]

@dosu... how I converge this tool in above suggested? this tools bring more precise. Can you help in converging this snippet in your suggested code?

https://python.langchain.com/v0.2/docs/integrations/tools/tavily_search/

from langchain_community.tools import TavilySearchResults

tool = TavilySearchResults(
    max_results=5,
    search_depth="advanced",
    include_answer=True,
    include_raw_content=True,
    include_images=True,
    # include_domains=[...],
    # exclude_domains=[...],
    # name="...",            # overwrite default tool name
    # description="...",     # overwrite default tool description
    # args_schema=...,       # overwrite default args_schema: BaseModel
)

[dosubot[bot]]

To integrate the TavilySearchResults tool into the previously suggested code for sending multiple messages sequentially and collecting responses, follow these steps:

1. Install the required packages:

   pip install -U "langchain-community>=0.2.11" tavily-python
   export TAVILY_API_KEY="your-api-key"

2. Set up your Tavily API key:

   import getpass
   import os
   
   if not os.environ.get("TAVILY_API_KEY"):
       os.environ["TAVILY_API_KEY"] = getpass.getpass("Tavily API key:\n")

3. Instantiate the TavilySearchResults tool:

   from langchain_community.tools import TavilySearchResults
   
   tool = TavilySearchResults(
       max_results=5,
       search_depth="advanced",
       include_answer=True,
       include_raw_content=True,
       include_images=True,
   )

4. Integrate the tool into the sequential messaging code:

   import datetime
   from langchain_core.prompts import ChatPromptTemplate
   from langchain_core.runnables import RunnableConfig, chain
   
   # Define the current date
   today = datetime.datetime.today().strftime("%D")
   
   # Define the prompt template
   prompt = ChatPromptTemplate(
       [
           ("system", f"You are a helpful assistant. The date today is {today}."),
           ("human", "{user_input}"),
           ("placeholder", "{messages}"),
       ]
   )
   
   # Bind tools to the language model
   llm_with_tools = llm.bind_tools([tool])
   
   # Create the LLM chain
   llm_chain = prompt | llm_with_tools
   
   # Define the tool chain
   @chain
   def tool_chain(user_input: str, config: RunnableConfig):
       input_ = {"user_input": user_input}
       ai_msg = llm_chain.invoke(input_, config=config)
       tool_msgs = tool.batch(ai_msg.tool_calls, config=config)
       return llm_chain.invoke({**input_, "messages": [ai_msg, *tool_msgs]}, config=config)
   
   # List of messages to send
   messages = [
       "Give me one latest news on Apple Stock",
       "What is the weather like in New York?",
       "Tell me a joke",
       # Add more messages as needed
   ]
   
   # Configuration for the Runnable
   config = RunnableConfig(
       tags=["example"],
       metadata={"source": "user_request"},
       callbacks=None,
       run_name="sequential_message_run",
       max_concurrency=1,
       recursion_limit=25,
       configurable={},
       run_id=None
   )
   
   # Collect responses for each message
   responses = []
   for message in messages:
       response = tool_chain.invoke(message, config=config)
       responses.append(response)
   
   # Print the collected responses
   for i, response in enumerate(responses):
       print(f"Response {i+1}: {response}")

This code will sequentially send the queries to the TavilySearchResults tool and collect the responses. The TavilySearchResults tool is configured to return up to 5 results with advanced search depth, including answers, raw content, and images ^[1][2].

To continue talking to Dosu, mention @dosu.