How to access config variables in a tool ?

[mathlover777]

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

# #!/usr/bin/env python
from fastapi import FastAPI
from langchain.agents import AgentExecutor
from langchain.agents.format_scratchpad.openai_tools import (
    format_to_openai_tool_messages,
)
from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langserve import add_routes
from langserve.pydantic_v1 import BaseModel, Field
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_mongodb.chat_message_histories import MongoDBChatMessageHistory
from langchain_openai import ChatOpenAI
from langchain.agents import tool
import os
from pinecone import Pinecone
from algoliasearch.search_client import SearchClient
import openai
import json
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.agents import AgentExecutor
from typing import Any
from fastapi.middleware.cors import CORSMiddleware

pinecone_client = Pinecone(api_key=os.environ["PINECONE_API_KEY"])
pc_index = pinecone_client.Index(os.environ["PINECONE_INDEX"])
algolia_client = SearchClient.create(os.environ["ALGOLIA_APPLICATION_ID"], os.environ["ALGOLIA_API_KEY"])
alg_index = algolia_client.init_index(os.environ["ALGOLIA_INDEX"])
openai_client = openai.OpenAI(api_key=os.environ['OPENAI_API_KEY'])

class getInfoInput(BaseModel):
    food: str = Field(description="name of the food")

@tool("get_food_price", args_schema=getInfoInput)
def get_food_price(food :str) -> dict:
    """Return cost of a food"""
    # ideally this will call algolia and pinecone to do the search
    # but for this case, it does not matter
    return 100
tools = [get_food_price]

class getUserInfoInput(BaseModel):
    phone: str = Field(description="Users phone number")

@tool("save_user", args_schema=getUserInfoInput)
def save_user(phone :str) -> dict:
    """Save the user detail"""
    # I want the session_id of the chat here
    return

tools = [get_food_price, save_user]

system_prompt = """
You are a waiter named Mia, People ask you about price of food and you reply
"""

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            system_prompt,
        ),
        MessagesPlaceholder(variable_name="chat_history"),
        ("user", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ]
)

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0, streaming=True)
llm_with_tools = llm.bind_tools(tools)

agent = (
    {
        "input": lambda x: x["input"],
        "agent_scratchpad": lambda x: format_to_openai_tool_messages(
            x["intermediate_steps"]
        ),
        "chat_history": lambda x: x["chat_history"],
    }
    | prompt
    | llm_with_tools
    | OpenAIToolsAgentOutputParser()
)

agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)


agent_with_chat_history = RunnableWithMessageHistory(
    agent_executor,
    # This is needed because in most real world scenarios, a session id is needed
    # It isn't really used here because we are using a simple in memory ChatMessageHistory
    lambda session_id: MongoDBChatMessageHistory(
        session_id=session_id,
        connection_string=os.environ["MONGO_CONNECTION_STRING"],
        database_name=os.environ["MONGO_DB"],
        collection_name=os.environ["MONGO_COLLECTION"],
    ),
    input_messages_key="input",
    history_messages_key="chat_history",
)


app = FastAPI(
    title="LangChain Server",
    version="1.0",
    description="Spin up a simple api server using LangChain's Runnable interfaces",
)

class Input(BaseModel):
    input: str
    # The field extra defines a chat widget.
    # Please see documentation about widgets in the main README.
    # The widget is used in the playground.
    # Keep in mind that playground support for agents is not great at the moment.
    # To get a better experience, you'll need to customize the streaming output
    # for now.


class Output(BaseModel):
    output: Any

add_routes(
    app,
    agent_with_chat_history.with_types(input_type=Input, output_type=Output).with_config(
        {"run_name": "agent"}
    ),
)

# For health check, otherwise this will return 404
u/app.get("/")
def get_root():
    return {"message": "FastAPI running in a Docker container"}


# Set all CORS enabled origins
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
    expose_headers=["*"],
)

if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="localhost", port=8000)

Description

I am using Langserve to create a langchain agent with tool calling. Till now all is working as expected and I am able to host it in AWS ECS with CDK also and learnt a lot in the process. But one thing I am stuck, in my chat, users will give their phone number and I will store the user as a lead in a crm I built using mongoDB. However, in the crm I want to show the chat history also.

For the chat history, I am using the mongodb integration and its working as expected when I pass the sessionId in the api calls.

Now I want to create a tool say save_user which will take the phone number as input. I tested dummy tool calls and its working. but in the save_user function, I want to save the phone number and the associated sessionId. I did not find any documentation or tutorial on how to achieve this.

This is the tool

@tool("save_user", args_schema=getUserInfoInput)
def save_user(phone :str) -> dict:
    """Save the user detail"""
    # I want the session_id of the chat here
    return

System Info

❯ pip freeze | grep langchain
langchain==0.2.1
langchain-cli==0.0.24
langchain-core==0.2.3
langchain-mongodb==0.1.5
langchain-openai==0.1.8
langchain-text-splitters==0.2.0

[dosubot[bot]]

Hey there, @mathlover777! I'm here to assist you with any questions or issues you have. Let's tackle this together!

To access configuration variables, such as the sessionId, within a tool function in LangChain, you can use the Context class to retrieve the context value. Here is an example of how you can modify your save_user tool to access the sessionId and save it along with the phone number:

from langchain_core.beta.runnables.context import Context
from pymongo import MongoClient
import os

class getUserInfoInput(BaseModel):
    phone: str = Field(description="Users phone number")

@tool("save_user", args_schema=getUserInfoInput)
def save_user(phone: str) -> dict:
    """Save the user detail"""
    # Retrieve the current sessionId using Context
    current_session_id = Context.getter("sessionId").invoke(None)
    
    # Connect to MongoDB
    client = MongoClient(os.environ["MONGO_CONNECTION_STRING"])
    db = client[os.environ["MONGO_DB"]]
    collection = db[os.environ["MONGO_COLLECTION"]]
    
    # Save the user detail along with the sessionId
    collection.insert_one({
        "sessionId": current_session_id,
        "phone": phone
    })
    
    return {"status": "success", "sessionId": current_session_id}

tools = [get_food_price, save_user]

In this example, Context.getter("sessionId").invoke(None) is used to retrieve the current sessionId within the save_user function. This allows you to save the phone number along with the sessionId in your MongoDB CRM ^[1][2][3].

To continue talking to Dosu, mention @dosu.

[dosubot[bot]]

To set the sessionId within the FastAPI app context and avoid the KeyError, you need to ensure that the sessionId is set at the appropriate point in your request handling. Here is how you can achieve this:

1. Set the sessionId in the context within a request handler:
   Use a FastAPI dependency to set the sessionId at the start of each request.

2. Retrieve the sessionId in the save_user function:
   Use the Context.getter method to retrieve the sessionId.

Here is the updated code:

from fastapi import FastAPI, Request, Depends
from pymongo import MongoClient
from pydantic import BaseModel, Field
from langchain_core.tools import tool
from langchain_core.beta.runnables.context import Context
import os

app = FastAPI()

# MongoDB client setup
client = MongoClient(os.environ["MONGO_CONNECTION_STRING"])
db = client[os.environ["MONGO_DB"]]
collection = db[os.environ["MONGO_COLLECTION"]]

class getUserInfoInput(BaseModel):
    phone: str = Field(description="Users phone number")

@tool("save_user", args_schema=getUserInfoInput)
def save_user(phone: str) -> dict:
    """Save the user detail"""
    # Retrieve the current sessionId using Context
    current_session_id = Context.getter("sessionId").invoke(None)
    
    # Save the user detail along with the sessionId
    collection.insert_one({
        "sessionId": current_session_id,
        "phone": phone
    })
    
    return {"status": "success", "sessionId": current_session_id}

tools = [save_user]

# Dependency to set the sessionId in the context
async def set_session_id(request: Request):
    session_id = request.headers.get("X-Session-ID", "default_session_id")
    Context.setter("sessionId", session_id).invoke(None)

@app.post("/set_session")
async def set_session(request: Request, session_id: str):
    Context.setter("sessionId", session_id).invoke(None)
    return {"message": "Session ID set"}

@app.post("/save_user")
async def save_user_endpoint(request: Request, user_info: getUserInfoInput, session_id: str = Depends(set_session_id)):
    return save_user(user_info.phone)

# Initialize the agent and set the sessionId
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0, streaming=True)
llm_with_tools = llm.bind_tools(tools)

agent = (
    {
        "input": lambda x: x["input"],
        "agent_scratchpad": lambda x: format_to_openai_tool_messages(
            x["intermediate_steps"]
        ),
        "chat_history": lambda x: x["chat_history"],
    }
    | prompt
    | llm_with_tools
    | OpenAIToolsAgentOutputParser()
)

agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

agent_with_chat_history = RunnableWithMessageHistory(
    agent_executor,
    lambda session_id: MongoDBChatMessageHistory(
        session_id=session_id,
        connection_string=os.environ["MONGO_CONNECTION_STRING"],
        database_name=os.environ["MONGO_DB"],
        collection_name=os.environ["MONGO_COLLECTION"],
    ),
    input_messages_key="input",
    history_messages_key="chat_history",
)

app = FastAPI(
    title="LangChain Server",
    version="1.0",
    description="Spin up a simple api server using LangChain's Runnable interfaces",
)

In this example:

1. The set_session_id dependency sets the sessionId in the context for each request.
2. The save_user function retrieves the sessionId from the context and saves the user details along with the sessionId in MongoDB.
3. The set_session endpoint allows you to set the sessionId explicitly if needed.

Make sure to pass the sessionId in the request headers or set it explicitly using the /set_session endpoint to ensure the sessionId is available in the context when needed ^[1].

To continue talking to Dosu, mention @dosu.

[mathlover777]

@dosu-bot, this wont work, as why want the users interaction to be done only via the chat, why i have to call other endpoints, where i am anyways passing the session_id in config.configurable

[dosubot[bot]]

To set and retrieve the sessionId within the save_user function without calling other endpoints, you can use the sessionId attribute of the MultionUpdateSession class. Here is how you can do it:

1. Set the sessionId: You can set the sessionId by assigning a value to the sessionId attribute of the MultionUpdateSession instance.
2. Retrieve the sessionId: You can retrieve the sessionId by accessing the sessionId attribute of the MultionUpdateSession instance.

Here is an example of how you can do this:

from pymongo import MongoClient
from pydantic import BaseModel, Field
from langchain_core.tools import tool

class getUserInfoInput(BaseModel):
    phone: str = Field(description="Users phone number")

class MultionUpdateSession:
    def __init__(self):
        self.sessionId = None

    def save_user(self, phone: str):
        # Retrieve the sessionId
        retrieved_sessionId = self.sessionId
        
        # Connect to MongoDB
        client = MongoClient(os.environ["MONGO_CONNECTION_STRING"])
        db = client[os.environ["MONGO_DB"]]
        collection = db[os.environ["MONGO_COLLECTION"]]
        
        # Save the user detail along with the sessionId
        collection.insert_one({
            "sessionId": retrieved_sessionId,
            "phone": phone
        })
        
        return {"status": "success", "sessionId": retrieved_sessionId}

# Initialize the session
session = MultionUpdateSession()

@tool("save_user", args_schema=getUserInfoInput)
def save_user(phone: str) -> dict:
    return session.save_user(phone)

# Example of setting the sessionId
session.sessionId = "your_session_id_here"

tools = [save_user]

In this example:

1. The MultionUpdateSession class has a sessionId attribute.
2. The save_user function within the MultionUpdateSession class retrieves the sessionId and saves the user details along with the sessionId in MongoDB.
3. The sessionId is set directly on the session instance before calling the save_user function.

This approach ensures that the sessionId is available within the save_user function without needing to call other endpoints ^[1].

To continue talking to Dosu, mention @dosu.

[mathlover777]

@dosu-bot

# Example of setting the sessionId
session.sessionId = "your_session_id_here"

also whats about this MultionUpdateSession
again you are hardcoding, this is not what i asked, any idea can it be done via configurableParams ?

[dosubot[bot]]

To retrieve the sessionId within the save_user tool function without hardcoding it or calling other endpoints, you can modify the MultionCreateSession class to store the sessionId as an instance attribute when the session is created. Here is an example of how you can achieve this:

from pymongo import MongoClient
from pydantic import BaseModel, Field
from langchain_core.tools import tool
from typing import Optional, Type
from langchain_core.beta.runnables.context import Context

class CreateSessionSchema(BaseModel):
    query: str
    url: Optional[str] = "https://www.google.com/"

class MultionCreateSession:
    """Tool that creates a new Multion Browser Window with provided fields.

    Attributes:
        name: The name of the tool. Default: "create_multion_session"
        description: The description of the tool.
        args_schema: The schema for the tool's arguments.
    """

    name: str = "create_multion_session"
    description: str = """
        Create a new web browsing session based on a user's command or request. \
        The command should include the full info required for the session. \
        Also include an url (defaults to google.com if no better option) \
        to start the session. \
        Use this tool to create a new Browser Window with provided fields. \
        Always the first step to run any activities that can be done using browser.
        """
    args_schema: Type[CreateSessionSchema] = CreateSessionSchema
    session_id: Optional[str] = None  # Add an attribute to store sessionId

    def _run(
        self,
        query: str,
        url: Optional[str] = "https://www.google.com/",
        run_manager: Optional[CallbackManagerForToolRun] = None,
    ) -> dict:
        try:
            response = multion.new_session({"input": query, "url": url})
            self.session_id = response["session_id"]  # Store the sessionId
            return {
                "sessionId": self.session_id,
                "Response": response["message"],
            }
        except Exception as e:
            raise Exception(f"An error occurred: {e}")

    def get_session_id(self) -> Optional[str]:
        """Retrieve the stored sessionId."""
        return self.session_id

# Initialize the session
session = MultionCreateSession()

class getUserInfoInput(BaseModel):
    phone: str = Field(description="Users phone number")

@tool("save_user", args_schema=getUserInfoInput)
def save_user(phone: str) -> dict:
    """Save the user detail"""
    # Retrieve the current sessionId using the session instance
    current_session_id = session.get_session_id()
    
    # Connect to MongoDB
    client = MongoClient(os.environ["MONGO_CONNECTION_STRING"])
    db = client[os.environ["MONGO_DB"]]
    collection = db[os.environ["MONGO_COLLECTION"]]
    
    # Save the user detail along with the sessionId
    collection.insert_one({
        "sessionId": current_session_id,
        "phone": phone
    })
    
    return {"status": "success", "sessionId": current_session_id}

tools = [save_user]

# Example of setting the sessionId
session._run(query="example query")

# Now you can use the save_user tool without hardcoding the sessionId

In this example:

1. The MultionCreateSession class is modified to store the sessionId as an instance attribute.
2. The save_user function retrieves the sessionId from the MultionCreateSession instance.
3. The sessionId is set when the session is created using the _run method of the MultionCreateSession class.

This approach ensures that the sessionId is available within the save_user function without hardcoding it or calling other endpoints ^[1].

To continue talking to Dosu, mention @dosu.

[eyurtsev]

@mathlover777 tools don't currently expose the config parameter -- it's on the to do list. The easiest way to do this is by creating the tool dynamically during request time and binding to it the relevant information.

[mathlover777]

Thanks a lot for your response. I am very new to langchain, I got this code working by combining multiple tutorials. So can you please give some hint / snippet how this can be done ? to me the tool is just a function, so did not get how i create it dynamically during request time and bind it with informaiton.

Also my use case is at least feasible right ? using "bare metal" openai calls i did it, but i am pushing in my company to scrap that and migrate to langchain and langserve, and this is a final blocker i am facing from poc point of view. So if you can guide me a bit, i will be great help. Thanks in advance !

Added in edit:

where i am most confused is

class getUserInfoInput(BaseModel):
    phone: str = Field(description="Users phone number")

@tool("save_user", args_schema=getUserInfoInput)
def save_user(phone :str) -> dict:
    """Save the user detail"""
    # I want the session_id of the chat here
    return

tools = [get_food_price, save_user]
.......
.......
.......
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

Here I don't have the session_id, so how i dynamically create the tool ?

I also saw your comment here, #17232 (comment) but not clear to me , how I can put this working in my situation.

[mathlover777]

I dug through the code and saw the session_Id is passed in some places, so added a very ugly money patch and it seems to be working, though would happily take a cleaner solution. For now the workaround I got works at least for the invoke api end point.

inside the app folder, I added this file money_patch.py

from langchain.agents import AgentExecutor
from langchain_core.tools import BaseTool

from typing import (
    Any,
    AsyncIterator,
    Callable,
    Dict,
    Iterator,
    List,
    Optional,
    Sequence,
    Tuple,
    Union,
)
from langchain_core.tools import BaseTool
from langchain_core.agents import AgentAction, AgentFinish, AgentStep

from langchain_core.callbacks import (
    AsyncCallbackManagerForChainRun,
    AsyncCallbackManagerForToolRun,
    BaseCallbackManager,
    CallbackManagerForChainRun,
    CallbackManagerForToolRun,
    Callbacks,
)
from langchain.agents.tools import InvalidTool


async def _aperform_agent_action(
    self,
    name_to_tool_map: Dict[str, BaseTool],
    color_mapping: Dict[str, str],
    agent_action: AgentAction,
    run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
) -> AgentStep:
    if run_manager:
        await run_manager.on_agent_action(
            agent_action, verbose=self.verbose, color="green"
        )
    # Otherwise we lookup the tool
    # print(run_manager)
    print(run_manager.metadata["session_id"])
    if agent_action.tool in name_to_tool_map:
        tool = name_to_tool_map[agent_action.tool]
        return_direct = tool.return_direct
        color = color_mapping[agent_action.tool]
        tool_run_kwargs = self.agent.tool_run_logging_kwargs()
        if return_direct:
            tool_run_kwargs["llm_prefix"] = ""
        # We then call the tool on the tool input to get an observation
        agent_action.tool_input["session_id"] = run_manager.metadata["session_id"]
        print("inside aperform agent action", agent_action.tool_input)
        observation = await tool.arun(
            agent_action.tool_input,
            verbose=self.verbose,
            color=color,
            callbacks=run_manager.get_child() if run_manager else None,
            **tool_run_kwargs,
        )
        print("observation", observation)
    else:
        tool_run_kwargs = self.agent.tool_run_logging_kwargs()
        observation = await InvalidTool().arun(
            {
                "requested_tool_name": agent_action.tool,
                "available_tool_names": list(name_to_tool_map.keys()),
            },
            verbose=self.verbose,
            color=None,
            callbacks=run_manager.get_child() if run_manager else None,
            **tool_run_kwargs,
        )
    return AgentStep(action=agent_action, observation=observation)




AgentExecutor._aperform_agent_action = _aperform_agent_action



import uuid
from langchain_core.runnables import (
    Runnable,
    RunnableConfig,
    RunnableSerializable,
    ensure_config,
)

from langchain_core.callbacks import (
    AsyncCallbackManager,
    AsyncCallbackManagerForToolRun,
    BaseCallbackManager,
    CallbackManager,
    CallbackManagerForToolRun,
)
from inspect import signature


from langchain_core.runnables.config import (
    _set_config_context,
    patch_config,
    run_in_executor,
)
from contextvars import copy_context
from langchain_core.runnables.utils import accepts_context
import asyncio

from langchain_core.pydantic_v1 import (
    BaseModel,
    Extra,
    Field,
    ValidationError,
    create_model,
    root_validator,
    validate_arguments,
)

class ToolException(Exception):
    """Optional exception that tool throws when execution error occurs.

    When this exception is thrown, the agent will not stop working,
    but it will handle the exception according to the handle_tool_error
    variable of the tool, and the processing result will be returned
    to the agent as observation, and printed in red on the console.
    """

    pass

async def arun(
    self,
    tool_input: Union[str, Dict],
    verbose: Optional[bool] = None,
    start_color: Optional[str] = "green",
    color: Optional[str] = "green",
    callbacks: Callbacks = None,
    *,
    tags: Optional[List[str]] = None,
    metadata: Optional[Dict[str, Any]] = None,
    run_name: Optional[str] = None,
    run_id: Optional[uuid.UUID] = None,
    config: Optional[RunnableConfig] = None,
    **kwargs: Any,
) -> Any:
    """Run the tool asynchronously."""
    if not self.verbose and verbose is not None:
        verbose_ = verbose
    else:
        verbose_ = self.verbose
    callback_manager = AsyncCallbackManager.configure(
        callbacks,
        self.callbacks,
        verbose_,
        tags,
        self.tags,
        metadata,
        self.metadata,
    )
    new_arg_supported = signature(self._arun).parameters.get("run_manager")
    run_manager = await callback_manager.on_tool_start(
        {"name": self.name, "description": self.description},
        tool_input if isinstance(tool_input, str) else str(tool_input),
        color=start_color,
        name=run_name,
        inputs=tool_input,
        run_id=run_id,
        **kwargs,
    )
    try:
        print("tool_input", tool_input)
        parsed_input = self._parse_input(tool_input)
        if ("session_id" in tool_input):
            parsed_input["session_id"] = tool_input["session_id"]
        # We then call the tool on the tool input to get an observation
        tool_args, tool_kwargs = self._to_args_and_kwargs(parsed_input)
        child_config = patch_config(
            config,
            callbacks=run_manager.get_child(),
        )
        context = copy_context()
        context.run(_set_config_context, child_config)
        coro = (
            context.run(
                self._arun, *tool_args, run_manager=run_manager, **tool_kwargs
            )
            if new_arg_supported
            else context.run(self._arun, *tool_args, **tool_kwargs)
        )
        if accepts_context(asyncio.create_task):
            observation = await asyncio.create_task(coro, context=context)  # type: ignore
        else:
            observation = await coro

    except ValidationError as e:
        if not self.handle_validation_error:
            raise e
        elif isinstance(self.handle_validation_error, bool):
            observation = "Tool input validation error"
        elif isinstance(self.handle_validation_error, str):
            observation = self.handle_validation_error
        elif callable(self.handle_validation_error):
            observation = self.handle_validation_error(e)
        else:
            raise ValueError(
                f"Got unexpected type of `handle_validation_error`. Expected bool, "
                f"str or callable. Received: {self.handle_validation_error}"
            )
        return observation
    except ToolException as e:
        if not self.handle_tool_error:
            await run_manager.on_tool_error(e)
            raise e
        elif isinstance(self.handle_tool_error, bool):
            if e.args:
                observation = e.args[0]
            else:
                observation = "Tool execution error"
        elif isinstance(self.handle_tool_error, str):
            observation = self.handle_tool_error
        elif callable(self.handle_tool_error):
            observation = self.handle_tool_error(e)
        else:
            raise ValueError(
                f"Got unexpected type of `handle_tool_error`. Expected bool, str "
                f"or callable. Received: {self.handle_tool_error}"
            )
        await run_manager.on_tool_end(
            observation, color="red", name=self.name, **kwargs
        )
        return observation
    except (Exception, KeyboardInterrupt) as e:
        await run_manager.on_tool_error(e)
        raise e
    else:
        await run_manager.on_tool_end(
            observation, color=color, name=self.name, **kwargs
        )
        return observation


BaseTool.arun = arun

key changes are:

    if agent_action.tool in name_to_tool_map:
        tool = name_to_tool_map[agent_action.tool]
        return_direct = tool.return_direct
        color = color_mapping[agent_action.tool]
        tool_run_kwargs = self.agent.tool_run_logging_kwargs()
        if return_direct:
            tool_run_kwargs["llm_prefix"] = ""
        # We then call the tool on the tool input to get an observation
        agent_action.tool_input["session_id"] = run_manager.metadata["session_id"]

I do not know whether its reliable or not, i found this while debugging with vs code run_manager.metadata["session_id"] this contains the session id I pass at config.configurable , and have know idea if it will be removed from here or not and what happens with other runnables(!)

    try:
        print("tool_input", tool_input)
        parsed_input = self._parse_input(tool_input)
        if ("session_id" in tool_input):
            parsed_input["session_id"] = tool_input["session_id"]
        # We then call the tool on the tool input to get an observation
        tool_args, tool_kwargs = self._to_args_and_kwargs(parsed_input)

also my server.py looks like this:

# #!/usr/bin/env python
from fastapi import FastAPI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langserve import add_routes
from langserve.pydantic_v1 import BaseModel, Field
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_mongodb.chat_message_histories import MongoDBChatMessageHistory
from langchain_openai import ChatOpenAI
from langchain.agents import tool
import os
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from fastapi.middleware.cors import CORSMiddleware
from typing import Any
from langchain.agents import AgentExecutor
from langchain.agents import create_tool_calling_agent

from .monkey_patch import *

class FoodInput(BaseModel):
    food: str = Field(description="name of the food")

@tool("get_food_price", args_schema=FoodInput)
def get_food_price(
    food: str,
    **kwargs: Any,
):
    """
    Return cost of a food
    """
    print("food", food)
    print("kwargs", kwargs)
    return "100 rs"


tools = [get_food_price]

system_prompt = """
You are a waiter named Mia, People ask you about price of food and you reply
"""

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            system_prompt,
        ),
        MessagesPlaceholder(variable_name="chat_history"),
        ("user", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ]
)

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0, streaming=True)

agent = create_tool_calling_agent(llm, tools, prompt)

agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

agent_with_chat_history = RunnableWithMessageHistory(
    agent_executor,
    # This is needed because in most real world scenarios, a session id is needed
    # It isn't really used here because we are using a simple in memory ChatMessageHistory
    lambda session_id: MongoDBChatMessageHistory(
        session_id=session_id,
        connection_string=os.environ["MONGO_CONNECTION_STRING"],
        database_name="dev",
        collection_name="chat_histories",
    ),
    input_messages_key="input",
    history_messages_key="chat_history",
)


app = FastAPI(
    title="LangChain Server",
    version="1.0",
    description="Spin up a simple api server using LangChain's Runnable interfaces",
)

class Input(BaseModel):
    input: str
    # The field extra defines a chat widget.
    # Please see documentation about widgets in the main README.
    # The widget is used in the playground.
    # Keep in mind that playground support for agents is not great at the moment.
    # To get a better experience, you'll need to customize the streaming output
    # for now.


class Output(BaseModel):
    output: Any


add_routes(
    app,
    agent_with_chat_history.with_types(input_type=Input, output_type=Output).with_config(
        {"run_name": "agent"}
    ),
    # per_req_config_modifier=per_req_config_modifier,
)

# For health check, otherwise this will return 404
@app.get("/")
def get_root():
    return {"message": "FastAPI running in a Docker container"}



# Set all CORS enabled origins
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
    expose_headers=["*"],
)

if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="localhost", port=8000)

Note: I changed the function signature

class FoodInput(BaseModel):
    food: str = Field(description="name of the food")

@tool("get_food_price", args_schema=FoodInput)
def get_food_price(
    food: str,
    **kwargs: Any,
):

No idea if it has any impact with the LLM though. I saw the internal tool call generation JSON did not contain the session_id

@eyurtsev if you can please suggest a elegant approach would highly appreciate, this patchy solution makes my eye bleed :p

[yvesloy]

@mathlover777 tools don't currently expose the config parameter -- it's on the to do list. The easiest way to do this is by creating the tool dynamically during request time and binding to it the relevant information.

Is there a timeline on this?