Tool Use

Language models are great at generating text, but often we need them to take real-world actions, such as querying an API, accessing a database, or calling a service. Most LLM providers support this through tool use (also known as function calling), where you expose specific operations in your application that the model can invoke.

Based on the input it receives, a model may choose to invoke (or call) one or more tools to augment its response. Your application then runs the corresponding logic for the tool using the parameters provided by the model. You then return the result to the model, allowing it to include the output in its final response.

The Toolkit simplifies tool integration by offering a structured, type-safe approach to defining tools. It takes care of all the wiring between the model and your application - all you have to do is define the tool and implement its behavior.

Defining a Tool

Let’s walk through a complete example of how to define, implement, and use a tool that fetches a dad joke from the icanhazdadjoke.com API.

1. Define the Tool

We start by defining a tool that the language model will have access to using the Tool.make constructor.

This constructor accepts several parameters that allow us to fully describe the tool to the language model:

description: Provides an optional description of the tool
success: The type of value the tool will return if it succeeds
failure: The type of value the tool will return if it fails
parameters: The parameters that the tool should be called with

Example (Defining a Tool)

1
import { Tool } from "@effect/ai"
2
import { Schema } from "effect"
3

4
const GetDadJoke = Tool.make("GetDadJoke", {
5
  description: "Get a hilarious dad joke from the ICanHazDadJoke API",
6
  success: Schema.String,
7
  failure: Schema.Never,
8
  parameters: {
9
    searchTerm: Schema.String.annotations({
10
      description: "The search term to use to find dad jokes",
11
    }),
12
  },
13
})

Based on the above, a request to call the GetDadJoke tool:

Takes a single searchTerm parameter
Will return a string if it succeeds (i.e. the joke)
Does not have any expected failure scenarios

2. Create a Toolkit

Once we have a tool request defined, we can create a Toolkit, which is a collection of tools that the model will have access to.

Example (Creating a Toolkit)

1
import { Tool, Toolkit } from "@effect/ai"
2
import { Schema } from "effect"
3

4
const GetDadJoke = Tool.make("GetDadJoke", {
5
  description: "Get a hilarious dad joke from the ICanHazDadJoke API",
6
  success: Schema.String,
7
  failure: Schema.Never,
8
  parameters: {
9
    searchTerm: Schema.String.annotations({
10
      description: "The search term to use to find dad jokes",
11
    }),
12
  },
13
})
14

15
const DadJokeTools = Toolkit.make(GetDadJoke)

3. Implement the Logic

The .toLayer(...) method on a Toolkit allows you to define the handlers for each tool in the toolkit. Because .toLayer(...) takes an Effect, we can access services from our application to implement the tool call handlers.

Example (Implementing a Toolkit)

1
import { Tool, Toolkit } from "@effect/ai"
2
import { HttpClient, HttpClientRequest, HttpClientResponse } from "@effect/platform"
3
import { NodeHttpClient } from "@effect/platform-node"
4
import { Array, Effect, Schema } from "effect"
5

6
class DadJoke extends Schema.Class<DadJoke>("DadJoke")({
7
  id: Schema.String,
8
  joke: Schema.String,
9
}) {}
37 collapsed lines
10

11
class SearchResponse extends Schema.Class<SearchResponse>("SearchResponse")({
12
  results: Schema.Array(DadJoke),
13
}) {}
14

15
class ICanHazDadJoke extends Effect.Service<ICanHazDadJoke>()("ICanHazDadJoke", {
16
  dependencies: [NodeHttpClient.layerUndici],
17
  effect: Effect.gen(function* () {
18
    const httpClient = yield* HttpClient.HttpClient
19
    const httpClientOk = httpClient.pipe(
20
      HttpClient.filterStatusOk,
21
      HttpClient.mapRequest(HttpClientRequest.prependUrl("https://icanhazdadjoke.com")),
22
    )
23

24
    const search = Effect.fn("ICanHazDadJoke.search")(function* (searchTerm: string) {
25
      return yield* httpClientOk
26
        .get("/search", {
27
          acceptJson: true,
28
          urlParams: { searchTerm },
29
        })
30
        .pipe(
31
          Effect.flatMap(HttpClientResponse.schemaBodyJson(SearchResponse)),
32
          Effect.flatMap(({ results }) => Array.head(results)),
33
          Effect.map((joke) => joke.joke),
34
          Effect.orDie,
35
        )
36
    })
37

38
    return {
39
      search,
40
    } as const
41
  }),
42
}) {}
43

44
const GetDadJoke = Tool.make("GetDadJoke", {
45
  description: "Get a hilarious dad joke from the ICanHazDadJoke API",
46
  success: Schema.String,
47
  failure: Schema.Never,
48
  parameters: {
49
    searchTerm: Schema.String.annotations({
50
      description: "The search term to use to find dad jokes",
51
    }),
52
  },
53
})
54

55
const DadJokeTools = Toolkit.make(GetDadJoke)
56

57
const DadJokeToolHandlers = DadJokeTools.toLayer(
58
  Effect.gen(function* () {
59
    // Access the `ICanHazDadJoke` service
60
    const icanhazdadjoke = yield* ICanHazDadJoke
61
    return {
62
      // Implement the handler for the `GetDadJoke` tool call request
63
      GetDadJoke: ({ searchTerm }) => icanhazdadjoke.search(searchTerm),
64
    }
65
  }),
66
)

In the code above:

We access the ICanHazDadJoke service from our application
Register a handler for the GetDadJoke tool using .handle("GetDadJoke", ...)
Use the .search method on our ICanHazDadJoke service to search for a dad joke based on the tool call parameters

The result of calling .toLayer on a Toolkit is a Layer that contains the handlers for all the tools in our toolkit.

Because of this, it is quite simple to test a Toolkit by using .toLayer to create a separate Layer specifically for testing.

4. Give the Tools to the Model

Once the tools are defined and implemented, you can pass them along to the model at request time. Behind the scenes, the model is given a structured description of each tool and can choose to call one or more of them when responding to input.

Example (Using a Toolkit)

1
import { LanguageModel, Tool, Toolkit } from "@effect/ai"
2
import { Effect, Schema } from "effect"
3

4
const GetDadJoke = Tool.make("GetDadJoke", {
5
  description: "Get a hilarious dad joke from the ICanHazDadJoke API",
6
  success: Schema.String,
7
  failure: Schema.Never,
8
  parameters: {
9
    searchTerm: Schema.String.annotations({
10
      description: "The search term to use to find dad jokes",
11
    }),
12
  },
13
})
14

15
const DadJokeTools = Toolkit.make(GetDadJoke)
16

17
const generateDadJoke = LanguageModel.generateText({
18
  prompt: "Generate a dad joke about pirates",
19
  toolkit: DadJokeTools,
20
})

5. Bring It All Together

To make the program executable, we must provide the implementation of our tool call handlers:

Example (Providing the Tool Call Handlers to a Program)

1
import { LanguageModel, Tool, Toolkit } from "@effect/ai"
2
import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai"
3
import { HttpClient, HttpClientRequest, HttpClientResponse } from "@effect/platform"
4
import { NodeHttpClient } from "@effect/platform-node"
5
import { Array, Config, Console, Effect, Layer, Schema } from "effect"
6

7
class DadJoke extends Schema.Class<DadJoke>("DadJoke")({
8
  id: Schema.String,
9
  joke: Schema.String,
10
}) {}
51 collapsed lines
11

12
class SearchResponse extends Schema.Class<SearchResponse>("SearchResponse")({
13
  results: Schema.Array(DadJoke),
14
}) {}
15

16
class ICanHazDadJoke extends Effect.Service<ICanHazDadJoke>()("ICanHazDadJoke", {
17
  dependencies: [NodeHttpClient.layerUndici],
18
  effect: Effect.gen(function* () {
19
    const httpClient = yield* HttpClient.HttpClient
20
    const httpClientOk = httpClient.pipe(
21
      HttpClient.filterStatusOk,
22
      HttpClient.mapRequest(HttpClientRequest.prependUrl("https://icanhazdadjoke.com")),
23
    )
24

25
    const search = Effect.fn("ICanHazDadJoke.search")(function* (searchTerm: string) {
26
      return yield* httpClientOk
27
        .get("/search", {
28
          acceptJson: true,
29
          urlParams: { searchTerm },
30
        })
31
        .pipe(
32
          Effect.flatMap(HttpClientResponse.schemaBodyJson(SearchResponse)),
33
          Effect.flatMap(({ results }) => Array.head(results)),
34
          Effect.map((joke) => joke.joke),
35
          Effect.scoped,
36
          Effect.orDie,
37
        )
38
    })
39

40
    return {
41
      search,
42
    } as const
43
  }),
44
}) {}
45

46
const GetDadJoke = Tool.make("GetDadJoke", {
47
  description: "Get a hilarious dad joke from the ICanHazDadJoke API",
48
  success: Schema.String,
49
  failure: Schema.Never,
50
  parameters: {
51
    searchTerm: Schema.String.annotations({
52
      description: "The search term to use to find dad jokes",
53
    }),
54
  },
55
})
56

57
const DadJokeTools = Toolkit.make(GetDadJoke)
58

59
const DadJokeToolHandlers = DadJokeTools.toLayer(
60
  Effect.gen(function* () {
61
    const icanhazdadjoke = yield* ICanHazDadJoke
62
    return {
63
      GetDadJoke: ({ searchTerm }) => icanhazdadjoke.search(searchTerm),
64
    }
65
  }),
66
).pipe(Layer.provide(ICanHazDadJoke.Default))
67

68
const program = LanguageModel.generateText({
69
  prompt: "Generate a dad joke about pirates",
70
  toolkit: DadJokeTools,
71
}).pipe(
72
  Effect.flatMap((response) => Console.log(response.text)),
73
  Effect.provide(OpenAiLanguageModel.model("gpt-4o")),
74
)
75

76
const OpenAi = OpenAiClient.layerConfig({
77
  apiKey: Config.redacted("OPENAI_API_KEY"),
78
}).pipe(Layer.provide(NodeHttpClient.layerUndici))
79

80
program.pipe(Effect.provide([OpenAi, DadJokeToolHandlers]), Effect.runPromise)

Benefits

Type Safe

Every tool is fully described using Effect’s Schema, including inputs, outputs, and descriptions.

Effect Native

Tool call behavior is defined using Effect, so they can leverage all the power of Effect. This is especially useful when you need to access other services to support the implementation of your tool call handlers.

Injectable

Because implementing the handlers for an Toolkit results in a Layer, providing alternate implementation of tool call handlers in different environments is as simple as providing a different Layer to your program.

Separation of Concerns

The definition of a tool call request is cleanly separated from both the implementation of the tool behavior, as well as the business logic that calls the model.