LLM tools

An LLM tool (LLM means a large language model, the kind of AI model behind chat assistants) is a prompt you write once and reuse as a tool. Instead of calling a system, it fills your prompt with the tool’s inputs, asks an AI model, and returns the answer. Use it for small, repeatable jobs inside a bigger flow: summarize a support ticket, sort an email into a category, pull the order number and amount out of a message, or translate a reply.

Create one

1. Open Tools and click Create tool.
2. Under Execution method, pick Model prompt.
3. Give it a Tool name and a Description that says when to use it.
4. Under Model, pick a model. The picker lists every model your connected providers offer. If it is empty, connect a provider first under Models → Connect a provider (see Connect a provider).
5. Optionally write a System prompt: standing instructions such as “You are a concise summarizer”.
6. Write the Prompt template. Put an input in double curly braces, such as {{text}}, and it is filled in each time the tool runs.
7. Under Parameters, add each input the template uses (here, text).
8. Pick an Output mode: Raw text returns the answer as written; Structured JSON asks the model for data in a fixed shape, which you describe under Output JSON schema (a short description of the fields you want).
9. Adjust Temperature (lower is more predictable, higher more varied; 0.7 by default) and Max tokens (the longest answer allowed; 1024 by default) if you need to.
10. Click Create tool, then open it and use Test tool to try it.

Some tools that work well this way:

For developers

The tool definition

The prompt and model settings are the tool’s llmConfig:

{
  "name": "summarize_text",
  "description": "Summarize a text document into key points",
  "type": "function",
  "executionMethod": "llm",
  "parameters": {
    "type": "object",
    "properties": {
      "text": { "type": "string", "description": "Text to summarize" },
      "maxPoints": { "type": "integer", "description": "Maximum bullet points", "default": 5 }
    },
    "required": ["text"]
  },
  "llmConfig": {
    "providerId": "<provider id>",
    "model": "gpt-4o",
    "systemPrompt": "You are a concise summarizer. Extract key points from text.",
    "promptTemplate": "Summarize the following text into at most {{maxPoints}} bullet points:\n\n{{text}}",
    "temperature": 0.3,
    "maxTokens": 1024,
    "outputMode": "text"
  }
}

Output

In text mode the result is the model’s answer as a string. In json mode the schema is added to the system prompt as an instruction, and the outermost JSON object in the answer is parsed and returned. The schema guides the model; it is not enforced. If the answer can’t be parsed, the result is { "raw": "<answer>", "parseError": "Could not parse as JSON" }.

{
  "outputMode": "json",
  "outputSchema": {
    "type": "object",
    "properties": {
      "summary": { "type": "string" },
      "keyPoints": { "type": "array", "items": { "type": "string" } },
      "sentiment": { "type": "string", "enum": ["positive", "neutral", "negative"] }
    },
    "required": ["summary", "keyPoints"]
  }
}

The run’s metadata carries the output mode, provider, model and the provider’s token usage. The call is made as the run’s user, so an LLM tool reaches only providers that user may use. It works with any provider you have connected; see Models.