@mastra/mcp-docs-server 0.13.24 → 0.13.25-alpha.1

package/.docs/raw/reference/core/getScorer.mdx

@@ -0,0 +1,75 @@
+---
+title: "Reference: getScorer() | Core | Mastra Docs"
+description: "Documentation for the `getScorer()` method in Mastra, which retrieves a specific scorer by its registration key."
+---
+
+# getScorer()
+
+The `getScorer()` method retrieves a specific scorer that was registered with the Mastra instance using its registration key. This method provides type-safe access to scorers and throws an error if the requested scorer is not found.
+
+## Usage Example
+
+```typescript
+import { mastra } from './mastra';
+
+// Get a specific scorer by key
+const relevancyScorer = mastra.getScorer('relevancyScorer');
+
+const weatherAgent = mastra.getAgent('weatherAgent')
+
+// Use the scorer to evaluate an AI output
+await weatherAgent.generate('What is the weather in Rome', {
+  scorers: {
+    answerRelevancy: {
+      scorer: relevancyScorer,
+    },
+  },
+});
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "key",
+      type: "string",
+      description: "The registration key of the scorer to retrieve. This should match a key used when registering scorers in the Mastra constructor.",
+      isOptional: false,
+    },
+  ]}
+/>
+
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "scorer",
+      type: "MastraScorer",
+      description: "The MastraScorer instance associated with the provided key.",
+    },
+  ]}
+/>
+
+## Error Handling
+
+This method throws a `MastraError` if:
+- The scorer with the specified key is not found
+- No scorers are registered with the Mastra instance
+
+```typescript
+try {
+  const scorer = mastra.getScorer('nonExistentScorer');
+} catch (error) {
+  if (error.id === 'MASTRA_GET_SCORER_NOT_FOUND') {
+    console.log('Scorer not found, using default evaluation');
+  }
+}
+```
+
+## Related
+
+- [getScorers()](../../reference/core/getScorers.mdx) - Get all registered scorers
+- [getScorerByName()](../../reference/core/getScorerByName.mdx) - Get a scorer by its name property
+- [Custom Scorers](../../docs/scorers/custom-scorers.mdx) - Learn how to create custom scorers

package/.docs/raw/reference/core/getScorerByName.mdx

@@ -0,0 +1,75 @@
+---
+title: "Reference: getScorerByName() | Core | Mastra Docs"
+description: "Documentation for the `getScorerByName()` method in Mastra, which retrieves a scorer by its name property rather than registration key."
+---
+
+# getScorerByName()
+
+The `getScorerByName()` method retrieves a scorer by searching for its `name` property rather than the registration key. This is useful when you know the scorer's display name but not necessarily how it was registered in the Mastra instance.
+
+## Usage Example
+
+```typescript
+import { mastra } from './mastra';
+
+// Get a scorer by its name property
+const relevancyScorer = mastra.getScorerByName('Answer Relevancy');
+
+const weatherAgent = mastra.getAgent('weatherAgent')
+
+// Use the scorer to evaluate an AI output
+await weatherAgent.generate('What is the weather in Rome', {
+  scorers: {
+    answerRelevancy: {
+      scorer: relevancyScorer,
+    },
+  },
+});
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "name",
+      type: "string",
+      description: "The name property of the scorer to retrieve. This should match the 'name' field specified when creating the scorer with createScorer().",
+      isOptional: false,
+    },
+  ]}
+/>
+
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "scorer",
+      type: "MastraScorer",
+      description: "The MastraScorer instance that has the matching name property.",
+    },
+  ]}
+/>
+
+## Error Handling
+
+This method throws a `MastraError` if:
+- No scorer with the specified name is found
+- No scorers are registered with the Mastra instance
+
+```typescript
+try {
+  const scorer = mastra.getScorerByName('Non-existent Scorer');
+} catch (error) {
+  if (error.id === 'MASTRA_GET_SCORER_BY_NAME_NOT_FOUND') {
+    console.log('Scorer with that name not found');
+  }
+}
+```
+
+## Related
+
+- [getScorer()](../../reference/core/getScorer) - Get a scorer by its registration key
+- [getScorers()](../../reference/core/getScorers) - Get all registered scorers
+- [createScorer()](../../reference/scorers/create-scorer) - Learn how to create scorers with names

package/.docs/raw/reference/core/getScorers.mdx

@@ -0,0 +1,42 @@
+---
+title: "Reference: getScorers() | Core | Mastra Docs"
+description: "Documentation for the `getScorers()` method in Mastra, which returns all registered scorers for evaluating AI outputs."
+---
+
+# getScorers()
+
+The `getScorers()` method returns all scorers that have been registered with the Mastra instance. Scorers are used for evaluating AI outputs and can override default scorers during agent generation or workflow execution.
+
+## Usage Example
+
+```typescript
+import { mastra } from './mastra';
+
+// Get all registered scorers
+const allScorers = mastra.getScorers();
+
+// Access a specific scorer
+const myScorer = allScorers.relevancyScorer;
+```
+
+## Parameters
+
+This method takes no parameters.
+
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "scorers",
+      type: "Record<string, MastraScorer> | undefined",
+      description: "An object containing all registered scorers, where keys are scorer names and values are MastraScorer instances. Returns undefined if no scorers are registered.",
+    },
+  ]}
+/>
+
+## Related
+
+- [getScorer()](../../reference/core/getScorer) - Get a specific scorer by key
+- [getScorerByName()](../../reference/core/getScorerByName) - Get a scorer by its name property
+- [Scorers Overview](../../docs/scorers/overview) - Learn about creating and using scorers

package/.docs/raw/reference/core/mastra-class.mdx

@@ -129,6 +129,13 @@ export const mastra = new Mastra({
       isOptional: true,
       defaultValue: "{ externals: [], sourcemap: false, transpilePackages: [] }",
     },
+    {
+      name: "scorers",
+      type: "Record<string, MastraScorer>",
+        description: "Scorers to register for scoring traces and overriding default scorers used during agent generation or workflow execution. Structured as a key-value pair, with keys being the scorer name and values being the scorer instance.",
+      isOptional: true,
+      defaultValue: "{}",
+    },
   ]}
 />
 

package/.docs/raw/reference/observability/ai-tracing/ai-tracing.mdx

@@ -0,0 +1,182 @@
+---
+title: "AITracing | AI Tracing | Reference"
+description: Core AI Tracing classes and methods
+asIndexPage: true
+---
+
+import { PropertiesTable } from "@/components/properties-table";
+
+# AITracing
+
+## DefaultAITracing
+
+Default implementation of the AITracing interface.
+
+### Constructor
+
+```typescript
+new DefaultAITracing(config: TracingConfig)
+```
+
+Creates a new DefaultAITracing instance with the specified configuration.
+
+### Properties
+
+Inherits all properties and methods from BaseAITracing.
+
+## BaseAITracing
+
+Base class for custom AI tracing implementations.
+
+### Methods
+
+#### getConfig
+
+```typescript
+getConfig(): Readonly<Required<TracingConfig>>
+```
+
+Returns the current tracing configuration.
+
+#### getExporters
+
+```typescript
+getExporters(): readonly AITracingExporter[]
+```
+
+Returns all configured exporters.
+
+#### getProcessors
+
+```typescript
+getProcessors(): readonly AISpanProcessor[]
+```
+
+Returns all configured processors.
+
+#### getLogger
+
+```typescript
+getLogger(): IMastraLogger
+```
+
+Returns the logger instance for exporters and other components.
+
+#### startSpan
+
+```typescript
+startSpan<TType extends AISpanType>(
+  options: StartSpanOptions<TType>
+): AISpan<TType>
+```
+
+Start a new span of a specific AISpanType. Creates the root span of a trace if no parent is provided.
+
+<PropertiesTable
+  props={[
+    {
+      name: "type",
+      type: "AISpanType",
+      description: "Type of span to create",
+      required: true,
+    },
+    {
+      name: "name",
+      type: "string",
+      description: "Name of the span",
+      required: true,
+    },
+    {
+      name: "parent",
+      type: "AnyAISpan",
+      description: "Parent span (if not root)",
+      required: false,
+    },
+    {
+      name: "attributes",
+      type: "AISpanTypeMap[TType]",
+      description: "Type-specific attributes",
+      required: false,
+    },
+    {
+      name: "metadata",
+      type: "Record<string, any>",
+      description: "User-defined metadata",
+      required: false,
+    },
+    {
+      name: "input",
+      type: "any",
+      description: "Initial input data",
+      required: false,
+    },
+    {
+      name: "customSamplerOptions",
+      type: "CustomSamplerOptions",
+      description: "Options for custom sampler",
+      required: false,
+    },
+  ]}
+/>
+
+#### shutdown
+
+```typescript
+async shutdown(): Promise<void>
+```
+
+Shuts down all exporters and processors, cleaning up resources.
+
+## Custom Implementation
+
+To create a custom AI tracing implementation, extend BaseAITracing:
+
+```typescript
+class CustomAITracing extends BaseAITracing {
+  constructor(config: TracingConfig) {
+    super(config);
+    // Custom initialization
+  }
+  
+  // Override methods as needed
+  startSpan<TType extends AISpanType>(
+    options: StartSpanOptions<TType>
+  ): AISpan<TType> {
+    // Custom span creation logic
+    return super.startSpan(options);
+  }
+}
+```
+
+## NO-OP Spans
+
+When tracing is disabled (sampling returns false), NO-OP spans are returned:
+
+### NoOpAISpan
+
+```typescript
+class NoOpAISpan<TType extends AISpanType> extends BaseAISpan<TType>
+```
+
+A span that performs no operations. All methods are no-ops:
+- `id` returns `'no-op'`
+- `traceId` returns `'no-op-trace'`
+- `isValid` returns `false`
+- `end()`, `error()`, `update()` do nothing
+- `createChildSpan()` returns another NO-OP span
+
+## See Also
+
+### Documentation
+- [AI Tracing Overview](/docs/observability/ai-tracing/overview) - Concepts and usage guide
+- [Configuration Reference](/reference/observability/ai-tracing/configuration) - Configuration options
+- [Interfaces Reference](/reference/observability/ai-tracing/interfaces) - Type definitions
+- [Span Reference](/reference/observability/ai-tracing/span) - Span lifecycle and methods
+
+### Examples
+- [Basic AI Tracing](/examples/observability/basic-ai-tracing) - Getting started example
+
+### Exporters
+- [DefaultExporter](/reference/observability/ai-tracing/exporters/default-exporter) - Storage persistence
+- [CloudExporter](/reference/observability/ai-tracing/exporters/cloud-exporter) - Mastra Cloud integration
+- [ConsoleExporter](/reference/observability/ai-tracing/exporters/console-exporter) - Debug output

package/.docs/raw/reference/observability/ai-tracing/configuration.mdx

@@ -0,0 +1,234 @@
+---
+title: "Configuration | AI Tracing | Reference"
+description: AI Tracing configuration types and registry functions
+---
+
+import { PropertiesTable } from "@/components/properties-table";
+
+# Configuration
+
+## ObservabilityRegistryConfig
+
+```typescript
+interface ObservabilityRegistryConfig {
+  default?: { enabled?: boolean };
+  configs?: Record<string, TracingConfig | AITracing>;
+  configSelector?: ConfigSelector;
+}
+```
+
+<PropertiesTable
+  props={[
+    {
+      name: "default",
+      type: "{ enabled?: boolean }",
+      description: "Enable default configuration",
+      required: false,
+    },
+    {
+      name: "configs",
+      type: "Record<string, TracingConfig | AITracing>",
+      description: "Named tracing configurations",
+      required: false,
+    },
+    {
+      name: "configSelector",
+      type: "ConfigSelector",
+      description: "Runtime configuration selector",
+      required: false,
+    },
+  ]}
+/>
+
+## TracingConfig
+
+```typescript
+interface TracingConfig {
+  name: string;
+  serviceName: string;
+  sampling?: SamplingStrategy;
+  exporters?: AITracingExporter[];
+  processors?: AISpanProcessor[];
+}
+```
+
+<PropertiesTable
+  props={[
+    {
+      name: "name",
+      type: "string",
+      description: "Configuration identifier",
+      required: true,
+    },
+    {
+      name: "serviceName",
+      type: "string",
+      description: "Service name in traces",
+      required: true,
+    },
+    {
+      name: "sampling",
+      type: "SamplingStrategy",
+      description: "Sampling configuration",
+      required: false,
+    },
+    {
+      name: "exporters",
+      type: "AITracingExporter[]",
+      description: "Trace data exporters",
+      required: false,
+    },
+    {
+      name: "processors",
+      type: "AISpanProcessor[]",
+      description: "Span processors",
+      required: false,
+    },
+  ]}
+/>
+
+## SamplingStrategy
+
+```typescript
+type SamplingStrategy =
+  | { type: 'always' }
+  | { type: 'never' }
+  | { type: 'ratio', probability: number }
+  | { type: 'custom', sampler: (options?: TracingOptions) => boolean };
+```
+
+## ConfigSelector
+
+```typescript
+type ConfigSelector = (
+  options: ConfigSelectorOptions,
+  availableConfigs: Map<string, AITracing>
+) => string | undefined;
+```
+
+## ConfigSelectorOptions
+
+```typescript
+interface ConfigSelectorOptions {
+  metadata?: Record<string, any>;
+  runtimeContext?: Map<string, any>;
+}
+```
+
+# Registry Functions
+
+## setupAITracing
+
+```typescript
+function setupAITracing(config: ObservabilityRegistryConfig): void
+```
+
+Initializes AI tracing from configuration. Called automatically by Mastra constructor.
+
+## registerAITracing
+
+```typescript
+function registerAITracing(
+  name: string,
+  instance: AITracing,
+  isDefault?: boolean
+): void
+```
+
+Registers a tracing config in the global registry.
+
+## getAITracing
+
+```typescript
+function getAITracing(name: string): AITracing | undefined
+```
+
+Retrieves a tracing config by name.
+
+## getDefaultAITracing
+
+```typescript
+function getDefaultAITracing(): AITracing | undefined
+```
+
+Returns the default tracing config.
+
+## getSelectedAITracing
+
+```typescript
+function getSelectedAITracing(
+  options: ConfigSelectorOptions
+): AITracing | undefined
+```
+
+Returns the tracing config selected by the config selector or default.
+
+## setSelector
+
+```typescript
+function setSelector(selector: ConfigSelector): void
+```
+
+Sets the global config selector function.
+
+## unregisterAITracing
+
+```typescript
+function unregisterAITracing(name: string): boolean
+```
+
+Removes a tracing config from the registry.
+
+## shutdownAITracingRegistry
+
+```typescript
+async function shutdownAITracingRegistry(): Promise<void>
+```
+
+Shuts down all tracing configs and clears the registry.
+
+## clearAITracingRegistry
+
+```typescript
+function clearAITracingRegistry(): void
+```
+
+Clears all configs without shutdown.
+
+## getAllAITracing
+
+```typescript
+function getAllAITracing(): ReadonlyMap<string, AITracing>
+```
+
+Returns all registered tracing configs.
+
+## hasAITracing
+
+```typescript
+function hasAITracing(name: string): boolean
+```
+
+Checks if a tracing instance exists and is enabled.
+
+## See Also
+
+### Documentation
+- [AI Tracing Overview](/docs/observability/ai-tracing/overview) - Concepts and usage guide
+- [Sampling Strategies](/docs/observability/ai-tracing/overview#sampling-strategies) - Sampling configuration details
+- [Multi-Config Setup](/docs/observability/ai-tracing/overview#multi-config-setup) - Using multiple configurations
+
+### Reference
+- [AITracing Classes](/reference/observability/ai-tracing/ai-tracing) - Core tracing classes
+- [Interfaces](/reference/observability/ai-tracing/interfaces) - Type definitions
+- [Span Reference](/reference/observability/ai-tracing/span) - Span lifecycle
+
+### Examples
+- [Basic AI Tracing](/examples/observability/basic-ai-tracing) - Getting started
+
+### Exporters
+- [DefaultExporter](/reference/observability/ai-tracing/exporters/default-exporter) - Storage configuration
+- [CloudExporter](/reference/observability/ai-tracing/exporters/cloud-exporter) - Cloud setup
+- [Braintrust](/reference/observability/ai-tracing/exporters/braintrust) - Braintrust integration
+- [Langfuse](/reference/observability/ai-tracing/exporters/langfuse) - Langfuse integration
+- [LangSmith](/reference/observability/ai-tracing/exporters/langsmith) - LangSmith integration