Defines a "function" that can be provided to an LLM for the LLM to optionally execute and pass argument data to.

A function is defined using a schema.

• name - The name of the function given to the LLM.
• description - A description of the function provided to the LLM. This should describe what the function is used for or what it returns. This information is used by the LLM to decide which function to call and for what purpose.
• parameters - A list of Function.FunctionParam structs that are converted to a JSONSchema format. (Use in place of parameters_schema)
• parameters_schema - A JSONSchema structure that describes the required data structure format for how arguments are passed to the function. (Use if greater control or unsupported features are needed.)
• function - An Elixir function to execute when an LLM requests to execute the function. The function should return {:ok, "and a text response"}, {:error, "and text explanation of the error"} or just plain "text response", which is returned to the LLM.
• async - Boolean value that flags if this can function can be executed asynchronously, potentially concurrently with other calls to the same function. Defaults to true.

When passing arguments from an LLM to a function, they go through a single map argument. This allows for multiple keys or named parameters.

Example

This example defines a function that an LLM can execute for performing basic math calculations. NOTE: This is a partial implementation of the LangChain.Tools.Calculator.

Function.new(%{
  name: "calculator",
  description: "Perform basic math calculations",
  parameters_schema: %{
    type: "object",
    properties: %{
      expression: %{type: "string", description: "A simple mathematical expression."}
    },
    required: ["expression"]
  },
  function:
    fn(%{"expression" => expr} = _args, _context) ->
      {:ok, "42?"}
    end)
})

The function attribute is an Elixir function that can be executed when the function is "called" by the LLM.

The args argument is the JSON data passed by the LLM after being parsed to a map.

The context argument is passed through as the context on a LangChain.Chains.LLMChain. This is whatever context data is needed for the function to do it's work.

Context examples may be user_id, account_id, account struct, billing level, etc.

Function Parameters

The parameters field is a list of LangChain.FunctionParam structs. This is a convenience for defining the parameters to the function. If it does not work for more complex use-cases, then use the parameters_schema to declare it as needed.

The parameters_schema is an Elixir map that follows a JSONSchema structure. It is used to define the required data structure format for receiving data to the function from the LLM.

NOTE: Only use parameters or parameters_schema, not both.

Expanded Parameter Examples

Function with no arguments:

alias LangChain.Function

Function.new!(%{name: "get_current_user_info"})

Function that takes a simple required argument:

alias LangChain.FunctionParam

Function.new!(%{name: "set_user_name", parameters: [
  FunctionParam.new!(%{name: "user_name", type: :string, required: true})
]})

Function that takes an array of strings:

Function.new!(%{name: "set_tags", parameters: [
  FunctionParam.new!(%{name: "tags", type: :array, item_type: "string"})
]})

Function that takes two arguments and one is an object/map:

Function.new!(%{name: "update_preferences", parameters: [
  FunctionParam.new!(%{name: "unique_code", type: :string, required: true})
  FunctionParam.new!(%{name: "data", type: :object, object_properties: [
    FunctionParam.new!(%{name: "auto_complete_email", type: :boolean}),
    FunctionParam.new!(%{name: "items_per_page", type: :integer}),
  ]})
]})

The LangChain.FunctionParam is nestable allowing for arrays of object and objects with nested objects.