@mastra/mcp-docs-server 0.13.10 → 0.13.11-alpha.1

package/.docs/raw/reference/agents/createTool.mdx

@@ -1,241 +0,0 @@
----
-title: "Reference: createTool() | Tools | Agents | Mastra Docs"
-description: Documentation for the createTool function in Mastra, which creates custom tools for agents and workflows.
----
-
-# `createTool()`
-
-The `createTool()` function creates typed tools that can be executed by agents or workflows. Tools have built-in schema validation, execution context, and integration with the Mastra ecosystem.
-
-## Overview
-
-Tools are a fundamental building block in Mastra that allow agents to interact with external systems, perform computations, and access data. Each tool has:
-
-- A unique identifier
-- A description that helps the AI understand when and how to use the tool
-- Optional input and output schemas for validation
-- An execution function that implements the tool's logic
-
-## Example Usage
-
-```ts filename="src/tools/stock-tools.ts" showLineNumbers copy
-import { createTool } from "@mastra/core/tools";
-import { z } from "zod";
-
-// Helper function to fetch stock data
-const getStockPrice = async (symbol: string) => {
-  const response = await fetch(
-    `https://mastra-stock-data.vercel.app/api/stock-data?symbol=${symbol}`,
-  );
-  const data = await response.json();
-  return data.prices["4. close"];
-};
-
-// Create a tool to get stock prices
-export const stockPriceTool = createTool({
-  id: "getStockPrice",
-  description: "Fetches the current stock price for a given ticker symbol",
-  inputSchema: z.object({
-    symbol: z.string().describe("The stock ticker symbol (e.g., AAPL, MSFT)"),
-  }),
-  outputSchema: z.object({
-    symbol: z.string(),
-    price: z.number(),
-    currency: z.string(),
-    timestamp: z.string(),
-  }),
-  execute: async ({ context }) => {
-    const price = await getStockPrice(context.symbol);
-
-    return {
-      symbol: context.symbol,
-      price: parseFloat(price),
-      currency: "USD",
-      timestamp: new Date().toISOString(),
-    };
-  },
-});
-
-// Create a tool that uses the thread context
-export const threadInfoTool = createTool({
-  id: "getThreadInfo",
-  description: "Returns information about the current conversation thread",
-  inputSchema: z.object({
-    includeResource: z.boolean().optional().default(false),
-  }),
-  execute: async ({ context, threadId, resourceId }) => {
-    return {
-      threadId,
-      resourceId: context.includeResource ? resourceId : undefined,
-      timestamp: new Date().toISOString(),
-    };
-  },
-});
-```
-
-## API Reference
-
-### Parameters
-
-`createTool()` accepts a single object with the following properties:
-
-<PropertiesTable
-  content={[
-    {
-      name: "id",
-      type: "string",
-      required: true,
-      description:
-        "Unique identifier for the tool. This should be descriptive of the tool's function.",
-    },
-    {
-      name: "description",
-      type: "string",
-      required: true,
-      description:
-        "Detailed description of what the tool does, when it should be used, and what inputs it requires. This helps the AI understand how to use the tool effectively.",
-    },
-    {
-      name: "execute",
-      type: "(context: ToolExecutionContext, options?: any) => Promise<any>",
-      required: false,
-      description:
-        "Async function that implements the tool's logic. Receives the execution context and optional configuration.",
-      properties: [
-        {
-          type: "ToolExecutionContext",
-          parameters: [
-            {
-              name: "context",
-              type: "object",
-              description:
-                "The validated input data that matches the inputSchema",
-            },
-            {
-              name: "threadId",
-              type: "string",
-              isOptional: true,
-              description:
-                "Identifier for the conversation thread, if available",
-            },
-            {
-              name: "resourceId",
-              type: "string",
-              isOptional: true,
-              description:
-                "Identifier for the user or resource interacting with the tool",
-            },
-            {
-              name: "mastra",
-              type: "Mastra",
-              isOptional: true,
-              description: "Reference to the Mastra instance, if available",
-            },
-          ],
-        },
-        {
-          type: "ToolOptions",
-          parameters: [
-            {
-              name: "toolCallId",
-              type: "string",
-              description:
-                "The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.",
-            },
-            {
-              name: "messages",
-              type: "CoreMessage[]",
-              description:
-                "Messages that were sent to the language model to initiate the response that contained the tool call. The messages do not include the system prompt nor the assistant response that contained the tool call.",
-            },
-            {
-              name: "abortSignal",
-              type: "AbortSignal",
-              isOptional: true,
-              description:
-                "An optional abort signal that indicates that the overall operation should be aborted.",
-            },
-          ],
-        },
-      ],
-    },
-    {
-      name: "inputSchema",
-      type: "ZodSchema",
-      required: false,
-      description:
-        "Zod schema that defines and validates the tool's input parameters. If not provided, the tool will accept any input.",
-    },
-    {
-      name: "outputSchema",
-      type: "ZodSchema",
-      required: false,
-      description:
-        "Zod schema that defines and validates the tool's output. Helps ensure the tool returns data in the expected format.",
-    },
-  ]}
-/>
-
-### Returns
-
-<PropertiesTable
-  content={[
-    {
-      name: "Tool",
-      type: "Tool<TSchemaIn, TSchemaOut>",
-      description:
-        "A Tool instance that can be used with agents, workflows, or directly executed.",
-      properties: [
-        {
-          type: "Tool",
-          parameters: [
-            {
-              name: "id",
-              type: "string",
-              description: "The tool's unique identifier",
-            },
-            {
-              name: "description",
-              type: "string",
-              description: "Description of the tool's functionality",
-            },
-            {
-              name: "inputSchema",
-              type: "ZodSchema | undefined",
-              description: "Schema for validating inputs",
-            },
-            {
-              name: "outputSchema",
-              type: "ZodSchema | undefined",
-              description: "Schema for validating outputs",
-            },
-            {
-              name: "execute",
-              type: "Function",
-              description: "The tool's execution function",
-            },
-          ],
-        },
-      ],
-    },
-  ]}
-/>
-
-## Type Safety
-
-The `createTool()` function provides full type safety through TypeScript generics:
-
-- Input types are inferred from the `inputSchema`
-- Output types are inferred from the `outputSchema`
-- The execution context is properly typed based on the input schema
-
-This ensures that your tools are type-safe throughout your application.
-
-## Best Practices
-
-1. **Descriptive IDs**: Use clear, action-oriented IDs like `getWeatherForecast` or `searchDatabase`
-2. **Detailed Descriptions**: Provide comprehensive descriptions that explain when and how to use the tool
-3. **Input Validation**: Use Zod schemas to validate inputs and provide helpful error messages
-4. **Error Handling**: Implement proper error handling in your execute function
-5. **Idempotency**: When possible, make your tools idempotent (same input always produces same output)
-6. **Performance**: Keep tools lightweight and fast to execute

package/.docs/raw/reference/scorers/custom-code-scorer.mdx

@@ -1,155 +0,0 @@
----
-title: "Reference: Create Custom Scorer | Scorers | Mastra Docs"
-description: Documentation for creating custom code scorers in Mastra, allowing users to define their own evaluation logic.
----
-
-# createScorer
-
-Mastra allows you to define your own custom code scorers for evaluating input/output pairs using any logic you choose. Custom scorers integrate seamlessly with the Mastra scoring framework and can be used anywhere built-in scorers are used.
-
-For a usage example, see the [Custom Code Scorer Examples](/examples/scorers/custom-native-javascript-eval).
-
-## How to Create a Custom Scorer
-
-Use the `createScorer` factory to define your scorer. You must provide at least a `name`, `description`, and an `analyze` function. Optionally, you can provide `extract` and `reason` functions for multi-step or more advanced logic.
-
-## createScorer Options
-
-<PropertiesTable
-  content={[
-    {
-      name: "name",
-      type: "string",
-      required: true,
-      description: "Name of the scorer.",
-    },
-    {
-      name: "description",
-      type: "string",
-      required: true,
-      description: "Description of what the scorer does.",
-    },
-    {
-      name: "analyze",
-      type: "function",
-      required: true,
-      description: "Main scoring logic",
-    },
-    {
-      name: "extract",
-      type: "function",
-      required: false,
-      description: "Optional pre-processing step.",
-    },
-    {
-      name: "reason",
-      type: "function",
-      required: false,
-      description: "Optional reason/explanation step.",
-    },
-    {
-      name: "metadata",
-      type: "object",
-      required: false,
-      description: "Optional metadata for the scorer.",
-    },
-  ]}
-/>
-
-This function returns an instance of the MastraScorer class. See the [MastraScorer reference](./mastra-scorer) for details on the `.run()` method and its input/output.
-
-## Step Function Signatures
-
-
-### extract
-<PropertiesTable
-  content={[
-    {
-      name: "input",
-      type: "Record<string, any>[]",
-      required: false,
-      description:
-        "Input records provided to the scorer. If the scorer is added to an agent, this will be an array of user messages, e.g. `[{ role: 'user', content: 'hello world' }]`. If the scorer is used in a workflow, this will be the input of the workflow.",
-    },
-    {
-      name: "output",
-      type: "Record<string, any>",
-      required: true,
-      description:
-        "Output record provided to the scorer. For agents, this is usually the agent's response. For workflows, this is the workflow's output.",
-    },
-  ]}
-/>
-Returns: `{ results: any }`  
-The method must return an object with a `results` property. The value of `results` will be passed to the analyze function as `extractStepResult`.
-
-### analyze
-<PropertiesTable
-  content={[
-    {
-      name: "input",
-      type: "Record<string, any>[]",
-      required: true,
-      description:
-        "Input records provided to the scorer. If the scorer is added to an agent, this will be an array of user messages, e.g. `[{ role: 'user', content: 'hello world' }]`. If the scorer is used in a workflow, this will be the input of the workflow.",
-    },
-    {
-      name: "output",
-      type: "Record<string, any>",
-      required: true,
-      description:
-        "Output record provided to the scorer. For agents, this is usually the agent's response. For workflows, this is the workflow's output.",
-    },
-    {
-      name: "extractStepResult",
-      type: "object",
-      required: false,
-      description: "Result of the extract step, if defined (optional).",
-    },
-  ]}
-/>
-Returns: `{ score: number, results?: any }`  
-The method must return an object with a `score` property (required). Optionally, it may return a `results` property. The value of `results` will be passed to the reason function as `analyzeStepResult`.
-
-
-### reason
-<PropertiesTable
-  content={[
-    {
-      name: "input",
-      type: "Record<string, any>[]",
-      required: true,
-      description:
-        "Input records provided to the scorer. If the scorer is added to an agent, this will be an array of user messages, e.g. `[{ role: 'user', content: 'hello world' }]`. If the scorer is used in a workflow, this will be the input of the workflow.",
-    },
-    {
-      name: "output",
-      type: "Record<string, any>",
-      required: true,
-      description:
-        "Output record provided to the scorer. For agents, this is usually the agent's response. For workflows, this is the workflow's output.",
-    },
-    {
-      name: "score",
-      type: "number",
-      required: true,
-      description: "Score computed by the analyze step.",
-    },
-    {
-      name: "analyzeStepResult",
-      type: "object",
-      required: true,
-      description: "Result of the analyze step.",
-    },
-    {
-      name: "extractStepResult",
-      type: "object",
-      required: false,
-      description: "Result of the extract step, if defined (optional).",  
-    },
-  ]}
-/>
-Returns: `{ reason: string }`  
-The method must return an object with a `reason` property, which should be a string explaining the score.
-
-All step functions can be async.

package/.docs/raw/reference/scorers/llm-scorer.mdx

@@ -1,210 +0,0 @@
----
-title: "Reference: createLLMScorer | Scorers | Mastra Docs"
-description: Documentation for creating LLM-based scorers in Mastra, allowing users to define evaluation logic using language models.
----
-
-# createLLMScorer
-
-The `createLLMScorer()` function lets you define custom scorers that use a language model (LLM) as a judge for evaluation. LLM scorers are ideal for tasks where you want to use prompt-based evaluation, such as answer relevancy, faithfulness, or custom prompt-based metrics. LLM scorers integrate seamlessly with the Mastra scoring framework and can be used anywhere built-in scorers are used.
-
-For a usage example, see the [Custom LLM Judge Examples](/examples/scorers/custom-llm-judge-eval).
-
-## createLLMScorer Options
-
-<PropertiesTable
-  content={[
-    {
-      name: "name",
-      type: "string",
-      required: true,
-      description: "Name of the scorer.",
-    },
-    {
-      name: "description",
-      type: "string",
-      required: true,
-      description: "Description of what the scorer does.",
-    },
-    {
-      name: "judge",
-      type: "object",
-      required: true,
-      description: "Judge configuration object. Must include a model and instructions (system prompt). See Judge Object section below.",
-    },
-    {
-      name: "extract",
-      type: "object",
-      required: false,
-      description: "(Optional) Extraction step configuration object. See Extract Object section below.",
-    },
-    {
-      name: "analyze",
-      type: "object",
-      required: true,
-      description: "Analysis step configuration object. See Analyze Object section below.",
-    },
-    {
-      name: "reason",
-      type: "object",
-      required: false,
-      description: "(Optional) Reason step configuration object. See Reason Object section below.",
-    },
-    {
-      name: "calculateScore",
-      type: "function",
-      required: true,
-      description: "Function: ({ run }) => number. Computes the final score from the analyze step result.",
-    },
-  ]}
-/>
-
-This function returns an instance of the MastraScorer class. See the [MastraScorer reference](./mastra-scorer) for details on the `.run()` method and its input/output.
-
-## Judge Object
-<PropertiesTable
-  content={[
-    {
-      name: "model",
-      type: "LanguageModel",
-      required: true,
-      description: "The LLM model instance to use for evaluation.",
-    },
-    {
-      name: "instructions",
-      type: "string",
-      required: true,
-      description: "System prompt/instructions for the LLM.",
-    },
-  ]}
-/>
-
-## Extract Object
-<PropertiesTable
-  content={[
-    {
-      name: "description",
-      type: "string",
-      required: true,
-      description: "Description of the extract step.",
-    },
-    {
-      name: "judge",
-      type: "object",
-      required: false,
-      description: "(Optional) LLM judge for this step (can override main judge/model). See Judge Object section.",
-    },
-    {
-      name: "outputSchema",
-      type: "ZodSchema",
-      required: true,
-      description: "Zod schema for the expected output of the extract step.",
-    },
-    {
-      name: "createPrompt",
-      type: "function",
-      required: true,
-      description: "Function: ({ run: ScoringInput }) => string. Returns the prompt for the LLM.",
-    },
-  ]}
-/>
-
-## Analyze Object
-<PropertiesTable
-  content={[
-    {
-      name: "description",
-      type: "string",
-      required: true,
-      description: "Description of the analyze step.",
-    },
-    {
-      name: "judge",
-      type: "object",
-      required: false,
-      description: "(Optional) LLM judge for this step (can override main judge/model). See Judge Object section.",
-    },
-    {
-      name: "outputSchema",
-      type: "ZodSchema",
-      required: true,
-      description: "Zod schema for the expected output of the analyze step.",
-    },
-    {
-      name: "createPrompt",
-      type: "function",
-      required: true,
-      description: "Function: ({ run: ScoringInput & { extractStepResult } }) => string. Returns the LLM prompt.",
-    },
-  ]}
-/>
-
-## Calculate Score Function
-
-The `calculateScore` function converts the LLM's structured analysis into a numerical score. This function receives the results from previous steps but not the score itself (since that's what it calculates).
-
-<PropertiesTable
-  content={[
-    {
-      name: "input",
-      type: "Record<string, any>[]",
-      required: true,
-      description:
-        "Input records provided to the scorer. If the scorer is added to an agent, this will be an array of user messages, e.g. `[{ role: 'user', content: 'hello world' }]`. If the scorer is used in a workflow, this will be the input of the workflow.",
-    },
-    {
-      name: "output",
-      type: "Record<string, any>",
-      required: true,
-      description:
-        "Output record provided to the scorer. For agents, this is usually the agent's response. For workflows, this is the workflow's output.",
-    },
-    {
-      name: "runtimeContext",
-      type: "object",
-      required: false,
-      description: "Runtime context from the agent or workflow step being evaluated (optional).",
-    },
-    {
-      name: "extractStepResult",
-      type: "object",
-      required: false,
-      description: "Result of the extract step, if defined (optional).",
-    },
-    {
-      name: "analyzeStepResult",
-      type: "object",
-      required: true,
-      description: "Structured result from the analyze step, conforming to the outputSchema defined in the analyze step.",
-    },
-  ]}
-/>
-
-Returns: `number`  
-The function must return a numerical score, typically in the 0-1 range where 1 represents the best possible score.
-
-## Reason Object
-<PropertiesTable
-  content={[
-    {
-      name: "description",
-      type: "string",
-      required: true,
-      description: "Description of the reason step.",
-    },
-    {
-      name: "judge",
-      type: "object",
-      required: false,
-      description: "(Optional) LLM judge for this step (can override main judge/model). See Judge Object section.",
-    },
-    {
-      name: "createPrompt",
-      type: "function",
-      required: true,
-      description: "Function: ({ run }) => string. `run` includes input, output, extractStepResult, analyzeStepResult, and score. Returns the prompt for the LLM.",
-    },
-  ]}
-/>
-
-LLM scorers may also include step-specific prompt fields in the return value, such as `extractPrompt`, `analyzePrompt`, and `reasonPrompt`.
-