Tools with Workflows

You can use workflows with tools to create reusable, multi-step processes that behave like standard tools. This is useful when you want to encapsulate complex logic behind a simple interface.

Creating a workflow

This example defines a two-step workflow:

getCityCoordinates: Looks up geolocation data for a given city.
getCityTemperature: Uses the coordinates to fetch the current temperature.

The workflow takes a city as input and outputs the temperature.

src/mastra/workflows/example-temperature-workflow.ts


import { createWorkflow, createStep } from "@mastra/core/workflows";
import { z } from "zod";
 
const getCityCoordinates = createStep({
  id: "get-city-coordinates",
  description: "Get geocoding details for a city",
  inputSchema: z.object({
    city: z.string()
  }),
  outputSchema: z.object({
    longitude: z.number(),
    latitude: z.number()
  }),
  execute: async ({ inputData }) => {
    const { city } = inputData;
 
    const response = await fetch(`https://geocoding-api.open-meteo.com/v1/search?name=${city}&count=1`);
 
    const { results } = await response.json();
    const { latitude, longitude } = results[0];
 
    return {
      latitude,
      longitude
    };
  }
});
 
const getCityTemperature = createStep({
  id: "get-city-temperature",
  description: "Get temperature for latitude/longitude",
  inputSchema: z.object({
    latitude: z.number(),
    longitude: z.number()
  }),
  outputSchema: z.object({
    temperature: z.string()
  }),
  execute: async ({ inputData }) => {
    const { latitude, longitude } = inputData;
 
    const response = await fetch(`https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current_weather=true`);
 
    const { current_weather, current_weather_units } = await response.json();
 
    return {
      temperature: `${current_weather.temperature} ${current_weather_units.temperature}`
    };
  }
});
 
export const temperatureWorkflow = createWorkflow({
  id: "temperature-workflow",
  inputSchema: z.object({
    city: z.string()
  }),
  outputSchema: z.object({
    temperature: z.string()
  })
})
  .then(getCityCoordinates)
  .then(getCityTemperature)
  .commit();

Running a workflow from a tool

This tool wraps the workflow and exposes it through a standard tool interface. It takes a city as input, runs the underlying workflow, and returns the resulting temperature.

src/mastra/tools/temperature-tool.ts


import { createTool } from "@mastra/core/tools";
import { z } from "zod";
 
export const getTemperatureTool = createTool({
  id: "get-temperature-tool",
  description: "Gets the temperature for a city",
  inputSchema: z.object({
    city: z.string()
  }),
  outputSchema: z.object({
    temperature: z.string()
  }),
  execute: async ({ context, mastra }) => {
    const { city } = context;
    const workflow = mastra!.getWorkflow("temperatureWorkflow");
    const run = await workflow!.createRunAsync({});
 
    const runResult = await run!.start({
      inputData: {
        city
      }
    });
 
    const { temperature } = (runResult as any).result;
 
    return {
      temperature
    };
  }
});

View Example on GitHub

Calling Tools

Tools with Workflows

Creating a workflow

Running a workflow from a tool

Related