@mastra/mcp-docs-server 0.0.5 → 0.0.6-alpha.2

package/.docs/raw/reference/rag/pinecone.mdx

@@ -46,7 +46,7 @@ It provides real-time vector search, with features like hybrid search, metadata
       type: "'cosine' | 'euclidean' | 'dotproduct'",
       isOptional: true,
       defaultValue: "cosine",
-      description: "Distance metric for similarity search",
+      description: "Distance metric for similarity search. Use 'dotproduct' if you plan to use hybrid search.",
     },
   ]}
 />
@@ -63,7 +63,13 @@ It provides real-time vector search, with features like hybrid search, metadata
     {
       name: "vectors",
       type: "number[][]",
-      description: "Array of embedding vectors",
+      description: "Array of dense embedding vectors",
+    },
+    {
+      name: "sparseVectors",
+      type: "{ indices: number[], values: number[] }[]",
+      isOptional: true,
+      description: "Array of sparse vectors for hybrid search. Each vector must have matching indices and values arrays.",
     },
     {
       name: "metadata",
@@ -77,6 +83,12 @@ It provides real-time vector search, with features like hybrid search, metadata
       isOptional: true,
       description: "Optional vector IDs (auto-generated if not provided)",
     },
+    {
+      name: "namespace",
+      type: "string",
+      isOptional: true,
+      description: "Optional namespace to store vectors in. Vectors in different namespaces are isolated from each other.",
+    },
   ]}
 />
 
@@ -92,7 +104,13 @@ It provides real-time vector search, with features like hybrid search, metadata
     {
       name: "vector",
       type: "number[]",
-      description: "Query vector to find similar vectors",
+      description: "Dense query vector to find similar vectors",
+    },
+    {
+      name: "sparseVector",
+      type: "{ indices: number[], values: number[] }",
+      isOptional: true,
+      description: "Optional sparse vector for hybrid search. Must have matching indices and values arrays.",
     },
     {
       name: "topK",
@@ -114,6 +132,12 @@ It provides real-time vector search, with features like hybrid search, metadata
       defaultValue: "false",
       description: "Whether to include the vector in the result",
     },
+    {
+      name: "namespace",
+      type: "string",
+      isOptional: true,
+      description: "Optional namespace to query vectors from. Only returns results from the specified namespace.",
+    },
   ]}
 />
 
@@ -244,6 +268,14 @@ Required environment variables:
 - `PINECONE_API_KEY`: Your Pinecone API key
 - `PINECONE_ENVIRONMENT`: Pinecone environment (e.g., 'us-west1-gcp')
 
-### Related
+## Hybrid Search
+
+Pinecone supports hybrid search by combining dense and sparse vectors. To use hybrid search:
+
+1. Create an index with `metric: 'dotproduct'`
+2. During upsert, provide sparse vectors using the `sparseVectors` parameter
+3. During query, provide a sparse vector using the `sparseVector` parameter
+
+## Related
 
 - [Metadata Filters](./metadata-filters)

package/.docs/raw/reference/rag/qdrant.mdx

@@ -231,6 +231,6 @@ try {
 }
 ```
 
-### Related
+## Related
 
 - [Metadata Filters](./metadata-filters)

package/.docs/raw/reference/rag/turbopuffer.mdx

@@ -244,6 +244,6 @@ try {
 }
 ```
 
-### Related
+## Related
 
 - [Metadata Filters](./metadata-filters)

package/.docs/raw/reference/rag/upstash.mdx

@@ -242,6 +242,6 @@ Required environment variables:
 - `UPSTASH_VECTOR_URL`: Your Upstash Vector database URL
 - `UPSTASH_VECTOR_TOKEN`: Your Upstash Vector API token
 
-### Related
+## Related
 
 - [Metadata Filters](./metadata-filters)

package/.docs/raw/reference/rag/vectorize.mdx

@@ -293,6 +293,6 @@ Required environment variables:
 - `CLOUDFLARE_ACCOUNT_ID`: Your Cloudflare account ID
 - `CLOUDFLARE_API_TOKEN`: Your Cloudflare API token with Vectorize permissions
 
-### Related
+## Related
 
 - [Metadata Filters](./metadata-filters)

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

@@ -18,7 +18,7 @@ npm install @mastra/pg
 ```typescript copy showLineNumbers
 import { PostgresStore } from "@mastra/pg";
 
-const storage = new PostgresStorage({
+const storage = new PostgresStore({
   connectionString: process.env.DATABASE_URL,
 });
 ```

package/.docs/raw/reference/workflows/createRun.mdx

@@ -33,7 +33,7 @@ const result = await start();
     },
     {
       name: "watch",
-      type: "(callback: (record: WorkflowRunState) => void) => () => void",
+      type: "(callback: (record: WorkflowResult) => void) => () => void",
       description: "Function that accepts a callback function that will be called with each transition of the workflow run",
     },
     {

package/.docs/raw/reference/workflows/resumeWithEvent.mdx

@@ -18,10 +18,10 @@ await run.resumeWithEvent(eventName: string, data: any): Promise<WorkflowRunResu
 
 ## Parameters
 
-| Parameter | Type | Description |
-|-----------|------|-------------|
+| Parameter | Type   | Description                                                                                             |
+| --------- | ------ | ------------------------------------------------------------------------------------------------------- |
 | eventName | string | The name of the event to trigger. Must match an event defined in the workflow's `events` configuration. |
-| data | any | The event data to provide. Must conform to the schema defined for that event. |
+| data      | any    | The event data to provide. Must conform to the schema defined for that event.                           |
 
 ## Return Value
 
@@ -58,17 +58,17 @@ This method is part of Mastra's event-driven workflow capabilities, allowing you
 
 ```typescript
 // Define and start a workflow
-const workflow = mastra.getWorkflow('approval-workflow');
+const workflow = mastra.getWorkflow("approval-workflow");
 const run = workflow.createRun();
 
 // Start the workflow
-await run.start({ triggerData: { requestId: 'req-123' } });
+await run.start({ triggerData: { requestId: "req-123" } });
 
 // Later, when the approval event occurs:
-const result = await run.resumeWithEvent('approval', {
+const result = await run.resumeWithEvent("approval", {
   approved: true,
-  approverName: 'John Doe',
-  comment: 'Looks good to me!'
+  approverName: "John Doe",
+  comment: "Looks good to me!",
 });
 
 console.log(result.results);
@@ -78,15 +78,15 @@ console.log(result.results);
 
 ```typescript
 try {
-  const result = await run.resumeWithEvent('paymentReceived', {
-    amount: 100.50,
-    transactionId: 'tx-456',
-    paymentMethod: 'credit-card',
+  const result = await run.resumeWithEvent("paymentReceived", {
+    amount: 100.5,
+    transactionId: "tx-456",
+    paymentMethod: "credit-card",
   });
 
-  console.log('Workflow resumed successfully:', result.results);
+  console.log("Workflow resumed successfully:", result.results);
 } catch (error) {
-  console.error('Failed to resume workflow with event:', error);
+  console.error("Failed to resume workflow with event:", error);
   // Handle error - could be invalid event data, workflow not suspended, etc.
 }
 ```
@@ -98,31 +98,30 @@ try {
 const { start, watch, resumeWithEvent } = workflow.createRun();
 
 // Watch for suspended event steps
-watch(async ({ context, activePaths }) => {
+watch(async ({ activePaths }) => {
+  const isApprovalEventSuspended =
+    activePaths.get("__approval_event")?.status === "suspended";
   // Check if suspended at the approval event step
-  if (activePaths.some(path =>
-    path.stepId === '__approval_event' &&
-    path.status === 'suspended'
-  )) {
-    console.log('Workflow waiting for approval');
+  if (isApprovalEventSuspended) {
+    console.log("Workflow waiting for approval");
 
     // In a real scenario, you would wait for the actual event
     // Here we're simulating with a timeout
     setTimeout(async () => {
       try {
-        await resumeWithEvent('approval', {
+        await resumeWithEvent("approval", {
           approved: true,
-          approverName: 'Auto Approver',
+          approverName: "Auto Approver",
         });
       } catch (error) {
-        console.error('Failed to auto-resume workflow:', error);
+        console.error("Failed to auto-resume workflow:", error);
       }
     }, 5000); // Wait 5 seconds before auto-approving
   }
 });
 
 // Start the workflow
-await start({ triggerData: { requestId: 'auto-123' } });
+await start({ triggerData: { requestId: "auto-123" } });
 ```
 
 ## Related

package/.docs/raw/reference/workflows/snapshots.mdx

@@ -36,31 +36,37 @@ A Mastra workflow snapshot consists of several key components:
 ```typescript
 export interface WorkflowRunState {
   // Core state info
-  value: Record<string, string>;      // Current state machine value
-  context: {                          // Workflow context
-    steps: Record<string, {           // Step execution results
-      status: 'success' | 'failed' | 'suspended' | 'waiting' | 'skipped';
-      payload?: any;                  // Step-specific data
-      error?: string;                 // Error info if failed
-    }>;
+  value: Record<string, string>; // Current state machine value
+  context: {
+    // Workflow context
+    steps: Record<
+      string,
+      {
+        // Step execution results
+        status: "success" | "failed" | "suspended" | "waiting" | "skipped";
+        payload?: any; // Step-specific data
+        error?: string; // Error info if failed
+      }
+    >;
     triggerData: Record<string, any>; // Initial trigger data
     attempts: Record<string, number>; // Remaining retry attempts
-    inputData: Record<string, any>; 	// Initial input data
+    inputData: Record<string, any>; // Initial input data
   };
 
-  activePaths: Array<{               // Currently active execution paths
+  activePaths: Array<{
+    // Currently active execution paths
     stepPath: string[];
     stepId: string;
     status: string;
   }>;
 
   // Metadata
-  runId: string;                     // Unique run identifier
-  timestamp: number;                 // Time snapshot was created
+  runId: string; // Unique run identifier
+  timestamp: number; // Time snapshot was created
 
   // For nested workflows and suspended steps
-  childStates?: Record<string, WorkflowRunState>;  // Child workflow states
-  suspendedSteps?: Record<string, string>;         // Mapping of suspended steps
+  childStates?: Record<string, WorkflowRunState>; // Child workflow states
+  suspendedSteps?: Record<string, string>; // Mapping of suspended steps
 }
 ```
 
@@ -82,7 +88,6 @@ When a workflow is suspended, Mastra automatically persists the workflow snapsho
 4. The snapshot is serialized and stored in the configured database in the `workflow_snapshots` table
 5. The storage record includes the workflow name, run ID, and the serialized snapshot
 
-
 ### Retrieving Snapshots
 
 When a workflow is resumed, Mastra retrieves the persisted snapshot with these steps:
@@ -105,8 +110,8 @@ This means that storage is shared across all workflows registered with the same
 The default storage option is LibSQL, a SQLite-compatible database:
 
 ```typescript
-import { Mastra } from '@mastra/core/mastra';
-import { DefaultStorage } from '@mastra/core/storage/libsql';
+import { Mastra } from "@mastra/core/mastra";
+import { DefaultStorage } from "@mastra/core/storage/libsql";
 
 const mastra = new Mastra({
   storage: new DefaultStorage({
@@ -115,12 +120,12 @@ const mastra = new Mastra({
       // For production:
       // url: process.env.DATABASE_URL,
       // authToken: process.env.DATABASE_AUTH_TOKEN,
-    }
+    },
   }),
   workflows: {
     weatherWorkflow,
     travelWorkflow,
-  }
+  },
 });
 ```
 
@@ -129,7 +134,7 @@ const mastra = new Mastra({
 For serverless environments:
 
 ```typescript
-import { Mastra } from '@mastra/core/mastra';
+import { Mastra } from "@mastra/core/mastra";
 import { UpstashStore } from "@mastra/upstash";
 
 const mastra = new Mastra({
@@ -140,7 +145,7 @@ const mastra = new Mastra({
   workflows: {
     weatherWorkflow,
     travelWorkflow,
-  }
+  },
 });
 ```
 
@@ -168,7 +173,7 @@ await suspend({
   requiredApprovers: ["manager", "finance"],
   requestedBy: currentUser,
   urgency: "high",
-  expires: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
+  expires: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
 });
 ```
 
@@ -179,18 +184,16 @@ This metadata is stored with the snapshot and available when resuming.
 You can implement conditional logic based on the suspend payload when resuming:
 
 ```typescript
-run.watch(async ({ context, activePaths }) => {
-  for (const path of activePaths) {
-    const approvalStep = context.steps?.approval;
-    if (approvalStep?.status === 'suspended') {
-      const payload = approvalStep.suspendPayload;
-
-      if (payload.urgency === "high" && currentUser.role === "manager") {
-        await resume({
-          stepId: 'approval',
-          context: { approved: true, approver: currentUser.id },
-        });
-      }
+run.watch(async ({ activePaths }) => {
+  const isApprovalStepSuspended =
+    activePaths.get("approval")?.status === "suspended";
+  if (isApprovalStepSuspended) {
+    const payload = activePaths.get("approval")?.suspendPayload;
+    if (payload.urgency === "high" && currentUser.role === "manager") {
+      await resume({
+        stepId: "approval",
+        context: { approved: true, approver: currentUser.id },
+      });
     }
   }
 });

package/.docs/raw/reference/workflows/suspend.mdx

@@ -63,16 +63,6 @@ const reviewStep = new Step({
 });
 ```
 
-Monitor suspended state:
-
-```typescript
-run.watch((state) => {
-  if (state.status === "SUSPENDED") {
-    notifyReviewers(state.metadata);
-  }
-});
-```
-
 ### Related
 
 - [Suspend & Resume Workflows](../../workflows/suspend-and-resume.mdx)

package/.docs/raw/reference/workflows/watch.mdx

@@ -19,9 +19,9 @@ const workflow = new Workflow({
 const run = workflow.createRun();
 
 // Subscribe to state changes
-const unsubscribe = run.watch((state) => {
-  console.log('Current step:', state.currentStep);
-  console.log('Step outputs:', state.stepOutputs);
+const unsubscribe = run.watch(({results, activePaths}) => {
+  console.log('Results:', results);
+  console.log('Active paths:', activePaths);
 });
 
 // Run the workflow
@@ -51,28 +51,28 @@ unsubscribe();
 <PropertiesTable
   content={[
     {
-      name: "currentStep",
-      type: "string",
-      description: "ID of the currently executing step",
+      name: "results",
+      type: "Record<string, any>",
+      description: "Outputs from completed workflow steps",
       isOptional: false
     },
     {
-      name: "stepOutputs",
-      type: "Record<string, any>",
-      description: "Outputs from completed workflow steps",
+      name: "activePaths",
+      type: "Map<string, { status: string; suspendPayload?: any; stepPath: string[] }>",
+      description: "Current status of each step",
       isOptional: false
     },
     {
-      name: "status",
-      type: "'running' | 'completed' | 'failed'",
-      description: "Current status of the workflow",
+      name: "runId",
+      type: "string",
+      description: "ID of the workflow run",
       isOptional: false
     },
     {
-      name: "error",
-      type: "Error | null",
-      description: "Error object if workflow failed",
-      isOptional: true
+      name: "timestamp",
+      type: "number",
+      description: "Timestamp of the workflow run",
+      isOptional: false
     }
   ]}
 />
@@ -94,9 +94,9 @@ unsubscribe();
 Monitor specific step completion:
 
 ```typescript
-run.watch((state) => {
-  if (state.currentStep === 'processDocument') {
-    console.log('Document processing output:', state.stepOutputs.processDocument);
+run.watch(({results, activePaths}) => {
+  if (activePaths.get('processDocument')?.status === 'completed') {
+    console.log('Document processing output:', results['processDocument'].output);
   }
 });
 ```
@@ -104,9 +104,9 @@ run.watch((state) => {
 Error handling:
 
 ```typescript
-run.watch((state) => {
-  if (state.status === 'failed') {
-    console.error('Workflow failed:', state.error);
+run.watch(({results, activePaths}) => {
+  if (activePaths.get('processDocument')?.status === 'failed') {
+    console.error('Document processing failed:', results['processDocument'].error);
     // Implement error recovery logic
   }
 });