@mastra/mcp-docs-server 0.13.34 → 0.13.35

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

@@ -0,0 +1,160 @@
+---
+title: "ArizeExporter | Exporters | AI Tracing | Reference"
+description: Arize exporter for AI tracing using OpenInference
+---
+
+import { PropertiesTable } from "@/components/properties-table";
+
+# ArizeExporter
+
+Sends AI tracing data to Arize Phoenix, Arize AX, or any OpenTelemetry-compatible observability platform that supports OpenInference semantic conventions.
+
+## Constructor
+
+```typescript
+new ArizeExporter(config: ArizeExporterConfig)
+```
+
+## ArizeExporterConfig
+
+```typescript
+interface ArizeExporterConfig {
+  // Phoenix / OpenTelemetry configuration
+  endpoint?: string;
+  apiKey?: string;
+
+  // Arize AX configuration
+  spaceId?: string;
+
+  // Common configuration
+  projectName?: string;
+  headers?: Record<string, string>;
+
+  // Inherited from OtelExporterConfig
+  timeout?: number;
+  batchSize?: number;
+  logLevel?: 'debug' | 'info' | 'warn' | 'error';
+  resourceAttributes?: Record<string, any>;
+}
+```
+
+<PropertiesTable
+  props={[
+    {
+      name: "endpoint",
+      type: "string",
+      description: "Collector endpoint for trace exports (e.g., 'http://localhost:6006/v1/traces' for Phoenix). Required for Phoenix. Optional for Arize AX (defaults to https://otlp.arize.com/v1/traces).",
+      required: false,
+    },
+    {
+      name: "apiKey",
+      type: "string",
+      description: "API key for authentication. Required for Phoenix Cloud and Arize AX. Optional for self-hosted Phoenix.",
+      required: false,
+    },
+    {
+      name: "spaceId",
+      type: "string",
+      description: "Arize AX space identifier. Required when sending traces to Arize AX.",
+      required: false,
+    },
+    {
+      name: "projectName",
+      type: "string",
+      description: "Project name added as OpenInference resource attribute",
+      required: false,
+    },
+    {
+      name: "headers",
+      type: "Record<string, string>",
+      description: "Additional headers for OTLP requests",
+      required: false,
+    },
+    {
+      name: "timeout",
+      type: "number",
+      description: "Timeout in milliseconds before exporting spans (default: 30000)",
+      required: false,
+    },
+    {
+      name: "batchSize",
+      type: "number",
+      description: "Number of spans to batch before export (default: 512)",
+      required: false,
+    },
+    {
+      name: "logLevel",
+      type: "'debug' | 'info' | 'warn' | 'error'",
+      description: "Logger level (default: 'warn')",
+      required: false,
+    },
+    {
+      name: "resourceAttributes",
+      type: "Record<string, any>",
+      description: "Custom resource attributes added to each span",
+      required: false,
+    },
+  ]}
+/>
+
+## Methods
+
+### exportEvent
+
+```typescript
+async exportEvent(event: AITracingEvent): Promise<void>
+```
+
+Exports a tracing event to the configured endpoint.
+
+### export
+
+```typescript
+async export(spans: ReadOnlyAISpan[]): Promise<void>
+```
+
+Batch exports spans using OpenTelemetry with OpenInference semantic conventions.
+
+### shutdown
+
+```typescript
+async shutdown(): Promise<void>
+```
+
+Flushes pending data and shuts down the client.
+
+## Usage
+
+### Phoenix Configuration
+
+```typescript
+import { ArizeExporter } from '@mastra/arize';
+
+const exporter = new ArizeExporter({
+  endpoint: 'http://localhost:6006/v1/traces',
+  apiKey: process.env.PHOENIX_API_KEY, // Optional for local Phoenix
+  projectName: 'my-ai-project',
+});
+```
+
+### Arize AX Configuration
+
+```typescript
+import { ArizeExporter } from '@mastra/arize';
+
+const exporter = new ArizeExporter({
+  spaceId: process.env.ARIZE_SPACE_ID!,
+  apiKey: process.env.ARIZE_API_KEY!,
+  projectName: 'my-ai-project',
+});
+```
+
+## OpenInference Semantic Conventions
+
+The ArizeExporter implements [OpenInference Semantic Conventions](https://github.com/Arize-ai/openinference/tree/main/spec) for generative AI applications, providing standardized trace structure across different observability platforms.
+
+## Related
+
+- [ArizeExporter Documentation](/docs/observability/ai-tracing/exporters/arize)
+- [Phoenix Documentation](https://docs.arize.com/phoenix)
+- [Arize AX Documentation](https://docs.arize.com/)

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

@@ -103,8 +103,8 @@ const exporter = new BraintrustExporter({
 
 | AI Span Type | Braintrust Type |
 |--------------|-----------------|
-| `LLM_GENERATION` | `llm` |
-| `LLM_CHUNK` | `llm` |
+| `MODEL_GENERATION` | `llm` |
+| `MODEL_CHUNK` | `llm` |
 | `TOOL_CALL` | `tool` |
 | `MCP_TOOL_CALL` | `tool` |
 | `WORKFLOW_CONDITIONAL_EVAL` | `function` |

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

@@ -111,6 +111,6 @@ const exporter = new LangfuseExporter({
 ## Span Mapping
 
 - Root spans → Langfuse traces
-- `LLM_GENERATION` spans → Langfuse generations
+- `MODEL_GENERATION` spans → Langfuse generations
 - All other spans → Langfuse spans
 - Event spans → Langfuse events

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

@@ -105,8 +105,8 @@ const exporter = new LangSmithExporter({
 
 | AI Span Type | LangSmith Type |
 |--------------|----------------|
-| `LLM_GENERATION` | `llm` |
-| `LLM_CHUNK` | `llm` |
+| `MODEL_GENERATION` | `llm` |
+| `MODEL_CHUNK` | `llm` |
 | `TOOL_CALL` | `tool` |
 | `MCP_TOOL_CALL` | `tool` |
 | All others | `chain` |

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

@@ -317,7 +317,7 @@ const exporter = new OtelExporter({
 The exporter maps Mastra AI spans to OpenTelemetry spans following GenAI semantic conventions:
 
 ### Span Names
-- `LLM_GENERATION` → `chat {model}` or `tool_selection {model}`
+- `MODEL_GENERATION` → `chat {model}` or `tool_selection {model}`
 - `TOOL_CALL` → `tool.execute {tool_name}`
 - `AGENT_RUN` → `agent.{agent_id}`
 - `WORKFLOW_RUN` → `workflow.{workflow_id}`

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

@@ -43,8 +43,9 @@ Mapping of span types to their corresponding attribute interfaces.
 interface AISpanTypeMap {
   AGENT_RUN: AgentRunAttributes;
   WORKFLOW_RUN: WorkflowRunAttributes;
-  LLM_GENERATION: LLMGenerationAttributes;
-  LLM_CHUNK: LLMChunkAttributes;
+  MODEL_GENERATION: ModelGenerationAttributes;
+  MODEL_STEP: ModelStepAttributes;
+  MODEL_CHUNK: ModelChunkAttributes;
   TOOL_CALL: ToolCallAttributes;
   MCP_TOOL_CALL: MCPToolCallAttributes;
   WORKFLOW_STEP: WorkflowStepAttributes;
@@ -160,16 +161,19 @@ AI-specific span types with their associated metadata.
 enum AISpanType {
   /** Agent run - root span for agent processes */
   AGENT_RUN = 'agent_run',
-  
+
   /** Generic span for custom operations */
   GENERIC = 'generic',
-  
-  /** LLM generation with model calls, token usage, prompts, completions */
-  LLM_GENERATION = 'llm_generation',
-  
-  /** Individual LLM streaming chunk/event */
-  LLM_CHUNK = 'llm_chunk',
-  
+
+  /** Model generation with model calls, token usage, prompts, completions */
+  MODEL_GENERATION = 'model_generation',
+
+  /** Single model execution step within a generation (one API call) */
+  MODEL_STEP = 'model_step',
+
+  /** Individual model streaming chunk/event */
+  MODEL_CHUNK = 'model_chunk',
+
   /** MCP (Model Context Protocol) tool execution */
   MCP_TOOL_CALL = 'mcp_tool_call',
   
@@ -235,19 +239,19 @@ interface AgentRunAttributes {
 }
 ```
 
-### LLMGenerationAttributes
+### ModelGenerationAttributes
 
-LLM Generation attributes.
+Model Generation attributes.
 
 ```typescript
-interface LLMGenerationAttributes {
+interface ModelGenerationAttributes {
   /** Model name (e.g., 'gpt-4', 'claude-3') */
   model?: string;
   
   /** Model provider (e.g., 'openai', 'anthropic') */
   provider?: string;
   
-  /** Type of result/output this LLM call produced */
+  /** Type of result/output this model call produced */
   resultType?: 'tool_selection' | 'response_generation' | 'reasoning' | 'planning';
   
   /** Token usage statistics */
@@ -280,12 +284,35 @@ interface LLMGenerationAttributes {
 }
 ```
 
-### LLMChunkAttributes
+### ModelStepAttributes
 
-LLM Chunk attributes - for individual streaming chunks/events.
+Model Step attributes - for a single model execution within a generation.
 
 ```typescript
-interface LLMChunkAttributes {
+interface ModelStepAttributes {
+  /** Index of this step in the generation (0, 1, 2, ...) */
+  stepIndex?: number;
+
+  /** Token usage statistics */
+  usage?: UsageStats;
+
+  /** Reason this step finished (stop, tool-calls, length, etc.) */
+  finishReason?: string;
+
+  /** Should execution continue */
+  isContinued?: boolean;
+
+  /** Result warnings */
+  warnings?: Record<string, any>;
+}
+```
+
+### ModelChunkAttributes
+
+Model Chunk attributes - for individual streaming chunks/events.
+
+```typescript
+interface ModelChunkAttributes {
   /** Type of chunk (text-delta, reasoning-delta, tool-call, etc.) */
   chunkType?: string;
   
@@ -626,10 +653,10 @@ enum InternalSpans {
   
   /** Tool spans are marked internal */
   TOOL = 1 << 2,
-  
-  /** LLM spans are marked internal */
-  LLM = 1 << 3,
-  
+
+  /** Model spans are marked internal */
+  MODEL = 1 << 3,
+
   /** All spans are marked internal */
   ALL = (1 << 4) - 1,
 }

package/.docs/raw/reference/storage/mongodb.mdx

@@ -0,0 +1,146 @@
+---
+title: "MongoDB Storage | Storage System | Mastra Core"
+description: Documentation for the MongoDB storage implementation in Mastra.
+---
+
+# MongoDB Storage
+
+The MongoDB storage implementation provides a scalable storage solution using MongoDB databases with support for both document storage and vector operations.
+
+## Installation
+
+```bash copy
+npm install @mastra/mongodb@latest
+```
+
+## Usage
+
+Ensure you have a MongoDB Atlas Local (via Docker) or MongoDB Atlas Cloud instance with Atlas Search enabled. MongoDB 7.0+ is recommended.
+
+```typescript copy showLineNumbers
+import { MongoDBStore } from "@mastra/mongodb";
+
+const storage = new MongoDBStore({
+  url: process.env.MONGODB_URL,
+  dbName: process.env.MONGODB_DATABASE,
+});
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "url",
+      type: "string",
+      description:
+        "MongoDB connection string (e.g., mongodb+srv://user:password@cluster.mongodb.net)",
+      isOptional: false,
+    },
+    {
+      name: "dbName",
+      type: "string",
+      description:
+        "The name of the database you want the storage to use.",
+      isOptional: false,
+    },
+    {
+      name: "options",
+      type: "MongoClientOptions",
+      description:
+        "MongoDB client options for advanced configuration (SSL, connection pooling, etc.). See advanced configuration [here](https://www.mongodb.com/docs/drivers/node/current/connect/connection-options/).",
+      isOptional: true,
+    }
+  ]}
+/>
+
+## Constructor Examples
+
+You can instantiate `MongoDBStore` in the following ways:
+
+```ts
+import { MongoDBStore } from "@mastra/mongodb";
+
+// Basic connection without custom options
+const store1 = new MongoDBStore({
+  url: "mongodb+srv://user:password@cluster.mongodb.net",
+  dbName: "mastra_storage",
+});
+
+// Using connection string with options
+const store2 = new MongoDBStore({
+  url: "mongodb+srv://user:password@cluster.mongodb.net",
+  dbName: "mastra_storage",
+  options: {
+    retryWrites: true,
+    maxPoolSize: 10,
+    serverSelectionTimeoutMS: 5000,
+    socketTimeoutMS: 45000,
+  },
+});
+```
+
+## Additional Notes
+
+### Collection Management
+
+The storage implementation handles collection creation and management automatically. It creates the following collections:
+
+- `mastra_workflow_snapshot`: Stores workflow state and execution data
+- `mastra_evals`: Stores evaluation results and metadata  
+- `mastra_threads`: Stores conversation threads
+- `mastra_messages`: Stores individual messages
+- `mastra_traces`: Stores telemetry and tracing data
+- `mastra_scorers`: Stores scoring and evaluation data
+- `mastra_resources`: Stores resource working memory data
+
+## Vector Search Capabilities
+
+MongoDB storage includes built-in vector search capabilities for AI applications:
+
+### Vector Index Creation
+
+```typescript copy
+import { MongoDBVector } from "@mastra/mongodb";
+
+const vectorStore = new MongoDBVector({
+  url: process.env.MONGODB_URL,
+  dbName: process.env.MONGODB_DATABASE,
+});
+
+// Create a vector index for embeddings
+await vectorStore.createIndex({
+  indexName: "document_embeddings",
+  dimension: 1536,
+});
+```
+
+### Vector Operations
+
+```typescript copy
+// Store vectors with metadata
+await vectorStore.upsert({
+  indexName: "document_embeddings",
+  vectors: [
+    {
+      id: "doc-1",
+      values: [0.1, 0.2, 0.3, ...], // 1536-dimensional vector
+      metadata: {
+        title: "Document Title",
+        category: "technical",
+        source: "api-docs",
+      },
+    },
+  ],
+});
+
+// Similarity search
+const results = await vectorStore.query({
+  indexName: "document_embeddings",
+  vector: queryEmbedding,
+  topK: 5,
+  filter: {
+    category: "technical",
+  },
+});
+```

package/.docs/raw/server-db/storage.mdx

@@ -512,3 +512,4 @@ Mastra supports the following providers:
 - For local development, check out [LibSQL Storage](../../reference/storage/libsql.mdx)
 - For production, check out [PostgreSQL Storage](../../reference/storage/postgresql.mdx)
 - For serverless deployments, check out [Upstash Storage](../../reference/storage/upstash.mdx)
+- For document-based storage, check out [MongoDB Storage](../../reference/storage/mongodb.mdx)

package/.docs/raw/workflows/agents-and-tools.mdx

@@ -63,7 +63,21 @@ export const testWorkflow = createWorkflow({
   .commit();
 ```
 
-> See [Input Data Mapping](./input-data-mapping.mdx) for more information.
+  > See [Input Data Mapping](./input-data-mapping.mdx) for more information.
+
+Mastra agents use a default schema that expects a `prompt` string as input and returns a `text` string as output:
+
+```json
+{
+  inputSchema: {
+    prompt: string
+  },
+  outputSchema: {
+    text: string
+  }
+}
+```
+
 
 ## Using tools in workflows