How does llm.bind_tools work in langchain?

[anmol-aidora]

I need to understand how exactly does langchain convert information from code to LLM prompt, because end of the day, the LLM will need only text to be passed to it.

If I am incorrect somewhere in my understanding, kindly point it out as well when answering the question

This is the bind_tools function:

class BaseChatOpenAI(BaseChatModel):
...
def bind_tools(
self,
tools: Sequence[Union[Dict[str, Any], Type, Callable, BaseTool]],
...
**kwargs: Any,
) -> Runnable[LanguageModelInput, BaseMessage]:
"""Bind tool-like objects to this chat model.

    Assumes model is compatible with OpenAI tool-calling API.
    """
    ...
    return super().bind(tools=formatted_tools, **kwargs)

On going to definition of super():

class Runnable(Generic[Input, Output], ABC):
...
def bind(self, **kwargs: Any) -> Runnable[Input, Output]:
"""
Bind arguments to a Runnable, returning a new Runnable.

    Useful when a Runnable in a chain requires an argument that is not

    """
    return RunnableBinding(bound=self, kwargs=kwargs, config={})

On going to RunnableBinding:

class RunnableBinding(RunnableBindingBase[Input, Output]):
"""Wrap a Runnable with additional functionality.

A RunnableBinding can be thought of as a "runnable decorator" that
preserves the essential features of Runnable; i.e., batching, streaming,
and async support, while adding additional functionality.

Any class that inherits from Runnable can be bound to a `RunnableBinding`.
Runnables expose a standard set of methods for creating `RunnableBindings`
or sub-classes of `RunnableBindings` (e.g., `RunnableRetry`,
`RunnableWithFallbacks`) that add additional functionality.

These methods include:

- ``bind``: Bind kwargs to pass to the underlying Runnable when running it.
- ``with_config``: Bind config to pass to the underlying Runnable when running it.
- ``with_listeners``:  Bind lifecycle listeners to the underlying Runnable.
- ``with_types``: Override the input and output types of the underlying Runnable.
- ``with_retry``: Bind a retry policy to the underlying Runnable.
- ``with_fallbacks``: Bind a fallback policy to the underlying Runnable.

Example:

`bind`: Bind kwargs to pass to the underlying Runnable when running it.

    .. code-block:: python

        # Create a Runnable binding that invokes the ChatModel with the
        # additional kwarg `stop=['-']` when running it.
        from langchain_community.chat_models import ChatOpenAI
        model = ChatOpenAI()
        model.invoke('Say "Parrot-MAGIC"', stop=['-']) # Should return `Parrot`
        # Using it the easy way via `bind` method which returns a new
        # RunnableBinding
        runnable_binding = model.bind(stop=['-'])
        runnable_binding.invoke('Say "Parrot-MAGIC"') # Should return `Parrot`

    Can also be done by instantiating a RunnableBinding directly (not recommended):

    .. code-block:: python

        from langchain_core.runnables import RunnableBinding
        runnable_binding = RunnableBinding(
            bound=model,
            kwargs={'stop': ['-']} # <-- Note the additional kwargs
        )
        runnable_binding.invoke('Say "Parrot-MAGIC"') # Should return `Parrot`
"""
...
def bind(self, **kwargs: Any) -> Runnable[Input, Output]:
    """Bind additional kwargs to a Runnable, returning a new Runnable.

    Args:
        **kwargs: The kwargs to bind to the Runnable.

    Returns:
        A new Runnable with the same type and config as the original,
        but with the additional kwargs bound.
    """
    return self.__class__(
        bound=self.bound,
        config=self.config,
        kwargs={**self.kwargs, **kwargs},
        custom_input_type=self.custom_input_type,
        custom_output_type=self.custom_output_type,
    )

After this, I am not able to understand how exactly the bind_tools function pass info to the LLM.