View Source LangChain.Function (LangChain v0.3.0-rc.0)
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 ofFunction.FunctionParam
structs that are converted to a JSONSchema format. (Use in place ofparameters_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 totrue
.
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.
Summary
Functions
Execute the function passing in arguments and additional optional context.
This is called by a LangChain.Chains.LLMChain
when a Function
execution is
requested by the LLM.
Given a list of functions, return the display_text
for the named function.
If it not found, return the fallback text.
Build a new function.
Build a new function and return it or raise an error if invalid.
Types
Functions
Execute the function passing in arguments and additional optional context.
This is called by a LangChain.Chains.LLMChain
when a Function
execution is
requested by the LLM.
get_display_text(functions, function_name, fallback_text \\ "Perform action")
View SourceGiven a list of functions, return the display_text
for the named function.
If it not found, return the fallback text.
@spec new(attrs :: map()) :: {:ok, t()} | {:error, Ecto.Changeset.t()}
Build a new function.
Build a new function and return it or raise an error if invalid.