@mastra/mcp-docs-server 0.13.37 → 0.13.38

package/.docs/raw/agents/guardrails.mdx

@@ -12,7 +12,7 @@ Processors can be configured as:
 - **`inputProcessors`**: Applied before messages reach the language model.
 - **`outputProcessors`**: Applied to responses before they're returned to users.
 
-Some processors are *hybrid*, meaning they can be used with either `inputProcessors` or `outputProcessors`, depending on where the logic should be applied.
+Some processors are _hybrid_, meaning they can be used with either `inputProcessors` or `outputProcessors`, depending on where the logic should be applied.
 
 ## When to use processors
 
@@ -22,7 +22,7 @@ Use processors for content moderation, prompt injection prevention, response san
 
 Import and instantiate the relevant processor class, and pass it to your agent’s configuration using either the `inputProcessors` or `outputProcessors` option:
 
-```typescript {3,9-17} filename="src/mastra/agents/moderated-agent.ts" showLineNumbers copy
+```typescript {3,9-17} title="src/mastra/agents/moderated-agent.ts" showLineNumbers copy
 import { openai } from "@ai-sdk/openai";
 import { Agent } from "@mastra/core/agent";
 import { ModerationProcessor } from "@mastra/core/processors";
@@ -38,8 +38,8 @@ export const moderatedAgent = new Agent({
       threshold: 0.7,
       strategy: "block",
       instructions: "Detect and flag inappropriate content in user messages",
-    })
-  ]
+    }),
+  ],
 });
 ```
 
@@ -51,7 +51,7 @@ Input processors are applied before user messages reach the language model. They
 
 The `UnicodeNormalizer` is an input processor that cleans and normalizes user input by unifying Unicode characters, standardizing whitespace, and removing problematic symbols, allowing the LLM to better understand user messages.
 
-```typescript {6-9} filename="src/mastra/agents/normalized-agent.ts" showLineNumbers copy
+```typescript {6-9} title="src/mastra/agents/normalized-agent.ts" showLineNumbers copy
 import { UnicodeNormalizer } from "@mastra/core/processors";
 
 export const normalizedAgent = new Agent({
@@ -60,18 +60,18 @@ export const normalizedAgent = new Agent({
     new UnicodeNormalizer({
       stripControlChars: true,
       collapseWhitespace: true,
-    })
+    }),
   ],
 });
 ```
 
-> See [UnicodeNormalizer](../../reference/processors/unicode-normalizer.mdx) for a full list of configuration options.
+> See [UnicodeNormalizer](/reference/processors/unicode-normalizer) for a full list of configuration options.
 
 ### Preventing prompt injection
 
 The `PromptInjectionDetector` is an input processor that scans user messages for prompt injection, jailbreak attempts, and system override patterns. It uses an LLM to classify risky input and can block or rewrite it before it reaches the model.
 
-```typescript {6-11} filename="src/mastra/agents/secure-agent.ts" showLineNumbers copy
+```typescript {6-11} title="src/mastra/agents/secure-agent.ts" showLineNumbers copy
 import { PromptInjectionDetector } from "@mastra/core/processors";
 
 export const secureAgent = new Agent({
@@ -80,20 +80,20 @@ export const secureAgent = new Agent({
     new PromptInjectionDetector({
       model: openai("gpt-4.1-nano"),
       threshold: 0.8,
-      strategy: 'rewrite',
-      detectionTypes: ['injection', 'jailbreak', 'system-override'],
-    })
+      strategy: "rewrite",
+      detectionTypes: ["injection", "jailbreak", "system-override"],
+    }),
   ],
 });
 ```
 
-> See [PromptInjectionDetector](../../reference/processors/prompt-injection-detector.mdx) for a full list of configuration options.
+> See [PromptInjectionDetector](/reference/processors/prompt-injection-detector) for a full list of configuration options.
 
 ### Detecting and translating language
 
 The `LanguageDetector` is an input processor that detects and translates user messages into a target language, enabling multilingual support while maintaining consistent interaction. It uses an LLM to identify the language and perform the translation.
 
-```typescript {6-11} filename="src/mastra/agents/multilingual-agent.ts" showLineNumbers copy
+```typescript {6-11} title="src/mastra/agents/multilingual-agent.ts" showLineNumbers copy
 import { LanguageDetector } from "@mastra/core/processors";
 
 export const multilingualAgent = new Agent({
@@ -101,15 +101,15 @@ export const multilingualAgent = new Agent({
   inputProcessors: [
     new LanguageDetector({
       model: openai("gpt-4.1-nano"),
-      targetLanguages: ['English', 'en'],
-      strategy: 'translate',
+      targetLanguages: ["English", "en"],
+      strategy: "translate",
       threshold: 0.8,
-    })
+    }),
   ],
 });
 ```
 
-> See [LanguageDetector](../../reference/processors/language-detector.mdx) for a full list of configuration options.
+> See [LanguageDetector](/reference/processors/language-detector) for a full list of configuration options.
 
 ## Output processors
 
@@ -119,7 +119,7 @@ Output processors are applied after the language model generates a response, but
 
 The `BatchPartsProcessor` is an output processor that combines multiple stream parts before emitting them to the client. This reduces network overhead and improves the user experience by consolidating small chunks into larger batches.
 
-```typescript {6-10} filename="src/mastra/agents/batched-agent.ts" showLineNumbers copy
+```typescript {6-10} title="src/mastra/agents/batched-agent.ts" showLineNumbers copy
 import { BatchPartsProcessor } from "@mastra/core/processors";
 
 export const batchedAgent = new Agent({
@@ -128,19 +128,19 @@ export const batchedAgent = new Agent({
     new BatchPartsProcessor({
       batchSize: 5,
       maxWaitTime: 100,
-      emitOnNonText: true
-    })
-  ]
+      emitOnNonText: true,
+    }),
+  ],
 });
 ```
 
-> See [BatchPartsProcessor](../../reference/processors/batch-parts-processor.mdx) for a full list of configuration options.
+> See [BatchPartsProcessor](/reference/processors/batch-parts-processor) for a full list of configuration options.
 
 ### Limiting token usage
 
 The `TokenLimiterProcessor` is an output processor that limits the number of tokens in model responses. It helps manage cost and performance by truncating or blocking messages when the limit is exceeded.
 
-```typescript {6-10, 13-15} filename="src/mastra/agents/limited-agent.ts" showLineNumbers copy
+```typescript {6-10, 13-15} title="src/mastra/agents/limited-agent.ts" showLineNumbers copy
 import { TokenLimiterProcessor } from "@mastra/core/processors";
 
 export const limitedAgent = new Agent({
@@ -149,19 +149,19 @@ export const limitedAgent = new Agent({
     new TokenLimiterProcessor({
       limit: 1000,
       strategy: "truncate",
-      countMode: "cumulative"
-    })
-  ]
-})
+      countMode: "cumulative",
+    }),
+  ],
+});
 ```
 
-> See [TokenLimiterProcessor](../../reference/processors/token-limiter-processor.mdx) for a full list of configuration options.
+> See [TokenLimiterProcessor](/reference/processors/token-limiter-processor) for a full list of configuration options.
 
 ### Scrubbing system prompts
 
 The `SystemPromptScrubber` is an output processor that detects and redacts system prompts or other internal instructions from model responses. It helps prevent unintended disclosure of prompt content or configuration details that could introduce security risks. It uses an LLM to identify and redact sensitive content based on configured detection types.
 
-```typescript {5-13} filename="src/mastra/agents/scrubbed-agent.ts" copy showLineNumbers
+```typescript {5-13} title="src/mastra/agents/scrubbed-agent.ts" copy showLineNumbers
 import { SystemPromptScrubber } from "@mastra/core/processors";
 
 const scrubbedAgent = new Agent({
@@ -171,15 +171,16 @@ const scrubbedAgent = new Agent({
       strategy: "redact",
       customPatterns: ["system prompt", "internal instructions"],
       includeDetections: true,
-      instructions: "Detect and redact system prompts, internal instructions, and security-sensitive content",
+      instructions:
+        "Detect and redact system prompts, internal instructions, and security-sensitive content",
       redactionMethod: "placeholder",
-      placeholderText: "[REDACTED]"
-    })
-  ]
+      placeholderText: "[REDACTED]",
+    }),
+  ],
 });
 ```
 
-> See [SystemPromptScrubber](../../reference/processors/system-prompt-scrubber.mdx) for a full list of configuration options.
+> See [SystemPromptScrubber](/reference/processors/system-prompt-scrubber) for a full list of configuration options.
 
 ## Hybrid processors
 
@@ -189,7 +190,7 @@ Hybrid processors can be applied either before messages are sent to the language
 
 The `ModerationProcessor` is a hybrid processor that detects inappropriate or harmful content across categories like hate, harassment, and violence. It can be used to moderate either user input or model output, depending on where it's applied. It uses an LLM to classify the message and can block or rewrite it based on your configuration.
 
-```typescript {6-11, 14-16} filename="src/mastra/agents/moderated-agent.ts" showLineNumbers copy
+```typescript {6-11, 14-16} title="src/mastra/agents/moderated-agent.ts" showLineNumbers copy
 import { ModerationProcessor } from "@mastra/core/processors";
 
 export const moderatedAgent = new Agent({
@@ -199,24 +200,24 @@ export const moderatedAgent = new Agent({
       model: openai("gpt-4.1-nano"),
       threshold: 0.7,
       strategy: "block",
-      categories: ["hate", "harassment", "violence"]
-    })
+      categories: ["hate", "harassment", "violence"],
+    }),
   ],
   outputProcessors: [
     new ModerationProcessor({
       // ...
-    })
-  ]
+    }),
+  ],
 });
 ```
 
-> See [ModerationProcessor](../../reference/processors/moderation-processor.mdx) for a full list of configuration options.
+> See [ModerationProcessor](/reference/processors/moderation-processor) for a full list of configuration options.
 
 ### Detecting and redacting PII
 
 The `PIIDetector` is a hybrid processor that detects and removes personally identifiable information such as emails, phone numbers, and credit cards. It can redact either user input or model output, depending on where it's applied. It uses an LLM to identify sensitive content based on configured detection types.
 
-```typescript {6-13, 16-18} filename="src/mastra/agents/private-agent.ts" showLineNumbers copy
+```typescript {6-13, 16-18} title="src/mastra/agents/private-agent.ts" showLineNumbers copy
 import { PIIDetector } from "@mastra/core/processors";
 
 export const privateAgent = new Agent({
@@ -225,21 +226,21 @@ export const privateAgent = new Agent({
     new PIIDetector({
       model: openai("gpt-4.1-nano"),
       threshold: 0.6,
-      strategy: 'redact',
-      redactionMethod: 'mask',
-      detectionTypes: ['email', 'phone', 'credit-card'],
-      instructions: "Detect and mask personally identifiable information."
-    })
+      strategy: "redact",
+      redactionMethod: "mask",
+      detectionTypes: ["email", "phone", "credit-card"],
+      instructions: "Detect and mask personally identifiable information.",
+    }),
   ],
   outputProcessors: [
     new PIIDetector({
       // ...
-    })
-  ]
+    }),
+  ],
 });
 ```
 
-> See [PIIDetector](../../reference/processors/pii-detector.mdx) for a full list of configuration options.
+> See [PIIDetector](/reference/processors/pii-detector) for a full list of configuration options.
 
 ## Applying multiple processors
 
@@ -253,13 +254,13 @@ A typical order might be:
 
 The order affects behavior, so arrange processors to suit your goals.
 
-```typescript filename="src/mastra/agents/test-agent.ts" showLineNumbers copy
+```typescript title="src/mastra/agents/test-agent.ts" showLineNumbers copy
 import {
   UnicodeNormalizer,
   ModerationProcessor,
   PromptInjectionDetector,
-  PIIDetector
-  } from "@mastra/core/processors";
+  PIIDetector,
+} from "@mastra/core/processors";
 
 export const testAgent = new Agent({
   // ...
@@ -275,7 +276,7 @@ export const testAgent = new Agent({
     }),
     new ModerationProcessor({
       // ...
-    })
+    }),
   ],
 });
 ```
@@ -286,7 +287,7 @@ Many of the built-in processors support a `strategy` parameter that controls how
 
 Most strategies allow the request to continue without interruption. When `block` is used, the processor calls its internal `abort()` function, which immediately stops the request and prevents any subsequent processors from running.
 
-```typescript {8} filename="src/mastra/agents/private-agent.ts" showLineNumbers copy
+```typescript {8} title="src/mastra/agents/private-agent.ts" showLineNumbers copy
 import { PIIDetector } from "@mastra/core/processors";
 
 export const privateAgent = new Agent({
@@ -294,10 +295,10 @@ export const privateAgent = new Agent({
   inputProcessors: [
     new PIIDetector({
       // ...
-      strategy: "block"
-    })
-  ]
-})
+      strategy: "block",
+    }),
+  ],
+});
 ```
 
 ### Handling blocked requests
@@ -309,15 +310,20 @@ For example, if an agent uses the `PIIDetector` with `strategy: "block"` and the
 #### `.generate()` example
 
 ```typescript {3-4, } showLineNumbers
-const result = await agent.generate("Is this credit card number valid?: 4543 1374 5089 4332");
+const result = await agent.generate(
+  "Is this credit card number valid?: 4543 1374 5089 4332",
+);
 
 console.error(result.tripwire);
 console.error(result.tripwireReason);
 ```
+
 #### `.stream()` example
 
 ```typescript {4-5} showLineNumbers
-const stream = await agent.stream("Is this credit card number valid?: 4543 1374 5089 4332");
+const stream = await agent.stream(
+  "Is this credit card number valid?: 4543 1374 5089 4332",
+);
 
 for await (const chunk of stream.fullStream) {
   if (chunk.type === "tripwire") {
@@ -325,6 +331,7 @@ for await (const chunk of stream.fullStream) {
   }
 }
 ```
+
 In this case, the `tripwireReason` indicates that a credit card number was detected:
 
 ```text
@@ -338,5 +345,5 @@ If the built-in processors don’t cover your needs, you can create your own by
 Available examples:
 
 - [Message Length Limiter](../../examples/processors/message-length-limiter)
-- [Response Length Limiter](../../examples/rocessors/response-length-limiter)
+- [Response Length Limiter](../../examples/processors/response-length-limiter)
 - [Response Validator](../../examples/processors/response-validator)

package/.docs/raw/agents/networks.mdx

@@ -23,44 +23,44 @@ Mastra agent networks operate using these principles:
 
 An agent network is built around a top-level routing agent that delegates tasks to agents, workflows, and tools defined in its configuration. Memory is configured on the routing agent using the `memory` option, and `instructions` define the agent's routing behavior.
 
-```typescript {22-23,26,29} filename="src/mastra/agents/routing-agent.ts" showLineNumbers copy
-  import { openai } from "@ai-sdk/openai";
-  import { Agent } from "@mastra/core/agent";
-  import { Memory } from "@mastra/memory";
-  import { LibSQLStore } from "@mastra/libsql";
+```typescript {22-23,26,29} title="src/mastra/agents/routing-agent.ts" showLineNumbers copy
+import { openai } from "@ai-sdk/openai";
+import { Agent } from "@mastra/core/agent";
+import { Memory } from "@mastra/memory";
+import { LibSQLStore } from "@mastra/libsql";
 
-  import { researchAgent } from "./research-agent";
-  import { writingAgent } from "./writing-agent";
+import { researchAgent } from "./research-agent";
+import { writingAgent } from "./writing-agent";
 
-  import { cityWorkflow } from "../workflows/city-workflow";
-  import { weatherTool } from "../tools/weather-tool";
+import { cityWorkflow } from "../workflows/city-workflow";
+import { weatherTool } from "../tools/weather-tool";
 
-  export const routingAgent = new Agent({
-    name: "routing-agent",
-    instructions: `
+export const routingAgent = new Agent({
+  name: "routing-agent",
+  instructions: `
       You are a network of writers and researchers.
       The user will ask you to research a topic.
       Always respond with a complete report—no bullet points.
       Write in full paragraphs, like a blog post.
       Do not answer with incomplete or uncertain information.`,
-    model: openai("gpt-4o-mini"),
-    agents: {
-      researchAgent,
-      writingAgent
-    },
-    workflows: {
-      cityWorkflow
-    },
-    tools: {
-      weatherTool
-    },
-    memory: new Memory({
-      storage: new LibSQLStore({
-        url: "file:../mastra.db"
-      })
-    })
-  });
-  ```
+  model: openai("gpt-4o-mini"),
+  agents: {
+    researchAgent,
+    writingAgent,
+  },
+  workflows: {
+    cityWorkflow,
+  },
+  tools: {
+    weatherTool,
+  },
+  memory: new Memory({
+    storage: new LibSQLStore({
+      url: "file:../mastra.db",
+    }),
+  }),
+});
+```
 
 ### Writing descriptions for network primitives
 
@@ -70,7 +70,7 @@ When configuring a Mastra agent network, each primitive (agent, workflow, or too
 
 Each agent in a network should include a clear `description` that explains what the agent does.
 
-```typescript filename="src/mastra/agents/research-agent.ts" showLineNumbers
+```typescript title="src/mastra/agents/research-agent.ts" showLineNumbers
 export const researchAgent = new Agent({
   name: "research-agent",
   description: `This agent gathers concise research insights in bullet-point form.
@@ -79,7 +79,8 @@ export const researchAgent = new Agent({
   // ...
 });
 ```
-```typescript filename="src/mastra/agents/writing-agent.ts" showLineNumbers
+
+```typescript title="src/mastra/agents/writing-agent.ts" showLineNumbers
 export const writingAgent = new Agent({
   name: "writing-agent",
   description: `This agent turns researched material into well-structured
@@ -93,7 +94,7 @@ export const writingAgent = new Agent({
 
 Workflows in a network should include a `description` to explain their purpose, along with `inputSchema` and `outputSchema` to describe the expected data.
 
-```typescript filename="src/mastra/workflows/city-workflow.ts" showLineNumbers
+```typescript title="src/mastra/workflows/city-workflow.ts" showLineNumbers
 export const cityWorkflow = createWorkflow({
   id: "city-workflow",
   description: `This workflow handles city-specific research tasks.
@@ -101,20 +102,20 @@ export const cityWorkflow = createWorkflow({
     that research into a full written report. Use it when the user input
     includes a city to be researched.`,
   inputSchema: z.object({
-    city: z.string()
+    city: z.string(),
   }),
   outputSchema: z.object({
-    text: z.string()
-  })
+    text: z.string(),
+  }),
   //...
-})
+});
 ```
 
 #### Tool descriptions
 
 Tools in a network should include a `description` to explain their purpose, along with `inputSchema` and `outputSchema` to describe the expected data.
 
-```typescript filename="src/mastra/tools/weather-tool.ts" showLineNumbers
+```typescript title="src/mastra/tools/weather-tool.ts" showLineNumbers
 export const weatherTool = createTool({
   id: "weather-tool",
   description: ` Retrieves current weather information using the wttr.in API.
@@ -122,10 +123,10 @@ export const weatherTool = createTool({
     Use this tool whenever up-to-date weather data is requested.
   `,
   inputSchema: z.object({
-    location: z.string()
+    location: z.string(),
   }),
   outputSchema: z.object({
-    weather: z.string()
+    weather: z.string(),
   }),
   // ...
 });
@@ -140,7 +141,9 @@ Call a Mastra agent network using `.network()` with a user message. The method r
 In this example, the network interprets the message and would route the request to both the `researchAgent` and `writingAgent` to generate a complete response.
 
 ```typescript showLineNumbers copy
-const result = await routingAgent.network("Tell me three cool ways to use Mastra");
+const result = await routingAgent.network(
+  "Tell me three cool ways to use Mastra",
+);
 
 for await (const chunk of result) {
   console.log(chunk.type);
@@ -174,7 +177,9 @@ network-execution-event-step-finish
 In this example, the routing agent recognizes the city name in the message and runs the `cityWorkflow`. The workflow defines steps that call the `researchAgent` to gather facts, then the `writingAgent` to generate the final text.
 
 ```typescript showLineNumbers copy
-const result = await routingAgent.network("Tell me some historical facts about London");
+const result = await routingAgent.network(
+  "Tell me some historical facts about London",
+);
 
 for await (const chunk of result) {
   console.log(chunk.type);
@@ -229,7 +234,6 @@ network-execution-event-step-finish
 
 ## Related
 
-- [Agent Memory](./agent-memory.mdx)
-- [Workflows Overview](../workflows/overview.mdx)
-- [Runtime Context](../server-db/runtime-context.mdx)
-
+- [Agent Memory](./agent-memory)
+- [Workflows Overview](../workflows/overview)
+- [Runtime Context](/docs/server-db/runtime-context)