Deploy a Mastra agent

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ES2022",
    "moduleResolution": "bundler",
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "skipLibCheck": true,
    "types": ["node"],
    "noEmit": true,
    "outDir": "dist"
  },
  "include": [
    "src/**/*"
  ]
}

import { createTool } from '@mastra/core/tools';
import { z } from 'zod';

export async function getWeather(city: string) {
  const geo = await fetch(
    `https://geocoding-api.open-meteo.com/v1/search?count=1&name=${encodeURIComponent(city)}`,
  ).then((res) => res.json());
  const place = geo.results?.[0];
  if (!place) throw new Error(`No location found for ${city}`);

  const forecast = await fetch(
    `https://api.open-meteo.com/v1/forecast?latitude=${place.latitude}&longitude=${place.longitude}` +
      '&daily=temperature_2m_max,temperature_2m_min,precipitation_probability_max&forecast_days=3&timezone=auto',
  ).then((res) => res.json());

  return {
    location: `${place.name}, ${place.country}`,
    days: forecast.daily.time.map((date: string, i: number) => ({
      date,
      maxC: forecast.daily.temperature_2m_max[i],
      minC: forecast.daily.temperature_2m_min[i],
      rainChance: forecast.daily.precipitation_probability_max[i],
    })),
  };
}

export const weatherTool = createTool({
  id: 'get-weather',
  description: 'Get the 3-day weather forecast for a city',
  inputSchema: z.object({ city: z.string() }),
  execute: async ({ city }) => getWeather(city),
});

import { Agent } from '@mastra/core/agent';
import { Memory } from '@mastra/memory';
import { weatherTool } from '../tools/weather-tool';

export const weatherAgent = new Agent({
  id: 'weather-agent',
  name: 'Weather Agent',
  instructions:
    'You help people plan around the weather. Use the get-weather tool for forecasts. Answer in 3 sentences or fewer.',
  model: 'anthropic/claude-haiku-5-5',
  tools: { weatherTool },
  memory: new Memory({ options: { lastMessages: 20 } }),
});

import { createStep, createWorkflow } from '@mastra/core/workflows';
import { z } from 'zod';
import { getWeather } from '../tools/weather-tool';

const forecastSchema = z.object({
  location: z.string(),
  days: z.array(z.object({ date: z.string(), maxC: z.number(), minC: z.number(), rainChance: z.number() })),
});

const fetchForecast = createStep({
  id: 'fetch-forecast',
  inputSchema: z.object({ city: z.string() }),
  outputSchema: forecastSchema,
  execute: async ({ inputData }) => getWeather(inputData.city),
});

const planActivities = createStep({
  id: 'plan-activities',
  inputSchema: forecastSchema,
  outputSchema: z.object({ plan: z.string() }),
  execute: async ({ inputData, mastra }) => {
    const agent = mastra.getAgent('weatherAgent');
    const result = await agent.generate(
      `Suggest one activity for each day of this forecast, one line per day: ${JSON.stringify(inputData)}`,
    );
    return { plan: result.text };
  },
});

export const weatherWorkflow = createWorkflow({
  id: 'weather-workflow',
  inputSchema: z.object({ city: z.string() }),
  outputSchema: z.object({ plan: z.string() }),
})
  .then(fetchForecast)
  .then(planActivities)
  .commit();

import { Mastra } from '@mastra/core/mastra';
import { SimpleAuth } from '@mastra/core/server';
import { PostgresStore } from '@mastra/pg';
import { weatherAgent } from './agents/weather-agent';
import { weatherWorkflow } from './workflows/weather-workflow';

export const mastra = new Mastra({
  agents: { weatherAgent },
  workflows: { weatherWorkflow },
  storage: new PostgresStore({ id: 'storage', connectionString: process.env.DB_URL }),
  server: {
    host: '0.0.0.0',
    drainTimeout: 10_000,
    auth: new SimpleAuth({
      tokens: process.env.MASTRA_API_TOKEN ? { [process.env.MASTRA_API_TOKEN]: { id: 'api' } } : {},
    }),
  },
});

FROM node:24-trixie AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:24-trixie-slim
WORKDIR /app
ENV NODE_ENV=production PORT=8080
COPY --from=build /app/.mastra/output ./
USER 1000:1000
EXPOSE 8080
CMD ["node", "index.mjs"]

.git
.mastra
node_modules
.env*
*.log
Dockerfile
.dockerignore