@mastra/mcp-docs-server 0.0.0-default-storage-virtual-file-20250410035748

package/.docs/raw/reference/client-js/agents.mdx

@@ -0,0 +1,107 @@
+# Agents API
+
+The Agents API provides methods to interact with Mastra AI agents, including generating responses, streaming interactions, and managing agent tools.
+
+## Getting All Agents
+
+Retrieve a list of all available agents:
+
+```typescript
+const agents = await client.getAgents();
+```
+
+## Working with a Specific Agent
+
+Get an instance of a specific agent:
+
+```typescript
+const agent = client.getAgent("agent-id");
+```
+
+## Agent Methods
+
+### Get Agent Details
+
+Retrieve detailed information about an agent:
+
+```typescript
+const details = await agent.details();
+```
+
+### Generate Response
+
+Generate a response from the agent:
+
+```typescript
+const response = await agent.generate({
+  messages: [
+    {
+      role: "user",
+      content: "Hello, how are you?",
+    },
+  ],
+  threadId: "thread-1", // Optional: Thread ID for conversation context
+  resourceid: "resource-1", // Optional: Resource ID
+  output: {}, // Optional: Output configuration
+});
+```
+
+### Stream Response
+
+Stream responses from the agent for real-time interactions:
+
+
+```typescript
+const response = await agent.stream({
+  messages: [
+    {
+      role: "user",
+      content: "Tell me a story",
+    },
+  ],
+});
+
+// Process data stream with the processDataStream util
+ response.processDataStream({
+      onTextPart: (text) => {
+        process.stdout.write(text);
+      },
+      onFilePart: (file) => {
+        console.log(file);
+      },
+      onDataPart: (data) => {
+        console.log(data);
+      },
+      onErrorPart: (error) => {
+        console.error(error);
+      },
+  });
+
+// You can also read from response body directly
+const reader = response.body.getReader();
+while (true) {
+  const { done, value } = await reader.read();
+  if (done) break;
+  console.log(new TextDecoder().decode(value));
+}
+```
+
+### Get Agent Tool
+
+Retrieve information about a specific tool available to the agent:
+
+```typescript
+const tool = await agent.getTool("tool-id");
+```
+
+### Get Agent Evaluations
+
+Get evaluation results for the agent:
+
+```typescript
+// Get CI evaluations
+const evals = await agent.evals();
+
+// Get live evaluations
+const liveEvals = await agent.liveEvals();
+```

package/.docs/raw/reference/client-js/error-handling.mdx

@@ -0,0 +1,38 @@
+# Error Handling
+
+The Mastra Client SDK includes built-in retry mechanism and error handling capabilities.
+
+## Error Handling
+
+All API methods can throw errors that you can catch and handle:
+
+```typescript
+try {
+  const agent = client.getAgent("agent-id");
+  const response = await agent.generate({
+    messages: [{ role: "user", content: "Hello" }],
+  });
+} catch (error) {
+  console.error("An error occurred:", error.message);
+}
+```
+
+## Retry Mechanism
+
+The client automatically retries failed requests with exponential backoff:
+
+```typescript
+const client = new MastraClient({
+  baseUrl: "http://localhost:4111",
+  retries: 3, // Number of retry attempts
+  backoffMs: 300, // Initial backoff time
+  maxBackoffMs: 5000, // Maximum backoff time
+});
+```
+
+### How Retries Work
+
+1. First attempt fails → Wait 300ms
+2. Second attempt fails → Wait 600ms
+3. Third attempt fails → Wait 1200ms
+4. Final attempt fails → Throw error

package/.docs/raw/reference/client-js/logs.mdx

@@ -0,0 +1,24 @@
+# Logs API
+
+The Logs API provides methods to access and query system logs and debugging information in Mastra.
+
+## Getting Logs
+
+Retrieve system logs with optional filtering:
+
+```typescript
+const logs = await client.getLogs({
+  transportId: "transport-1",
+});
+```
+
+## Getting Logs for a Specific Run
+
+Retrieve logs for a specific execution run:
+
+```typescript
+const runLogs = await client.getLogForRun({
+  runId: "run-1",
+  transportId: "transport-1",
+});
+```

package/.docs/raw/reference/client-js/memory.mdx

@@ -0,0 +1,97 @@
+# Memory API
+
+The Memory API provides methods to manage conversation threads and message history in Mastra.
+
+## Memory Thread Operations
+
+### Get All Threads
+
+Retrieve all memory threads for a specific resource:
+
+```typescript
+const threads = await client.getMemoryThreads({
+  resourceId: "resource-1",
+  agentId: "agent-1"
+});
+```
+
+### Create a New Thread
+
+Create a new memory thread:
+
+```typescript
+const thread = await client.createMemoryThread({
+  title: "New Conversation",
+  metadata: { category: "support" },
+  resourceid: "resource-1",
+  agentId: "agent-1"
+});
+```
+
+### Working with a Specific Thread
+
+Get an instance of a specific memory thread:
+
+```typescript
+const thread = client.getMemoryThread("thread-id", "agent-id");
+```
+
+## Thread Methods
+
+### Get Thread Details
+
+Retrieve details about a specific thread:
+
+```typescript
+const details = await thread.get();
+```
+
+### Update Thread
+
+Update thread properties:
+
+```typescript
+const updated = await thread.update({
+  title: "Updated Title",
+  metadata: { status: "resolved" },
+  resourceid: "resource-1",
+});
+```
+
+### Delete Thread
+
+Delete a thread and its messages:
+
+```typescript
+await thread.delete();
+```
+
+## Message Operations
+
+### Save Messages
+
+Save messages to memory:
+
+```typescript
+const savedMessages = await client.saveMessageToMemory({
+  messages: [
+    {
+      role: "user",
+      content: "Hello!",
+      id: "1",
+      threadId: "thread-1",
+      createdAt: new Date(),
+      type: "text",
+    },
+  ],
+  agentId: "agent-1"
+});
+```
+
+### Get Memory Status
+
+Check the status of the memory system:
+
+```typescript
+const status = await client.getMemoryStatus("agent-id");
+```

package/.docs/raw/reference/client-js/telemetry.mdx

@@ -0,0 +1,20 @@
+# Telemetry API
+
+The Telemetry API provides methods to retrieve and analyze traces from your Mastra application. This helps you monitor and debug your application's behavior and performance.
+
+## Getting Traces
+
+Retrieve traces with optional filtering and pagination:
+
+```typescript
+const telemetry = await client.getTelemetry({
+  name: "trace-name", // Optional: Filter by trace name
+  scope: "scope-name", // Optional: Filter by scope
+  page: 1, // Optional: Page number for pagination
+  perPage: 10, // Optional: Number of items per page
+  attribute: {
+    // Optional: Filter by custom attributes
+    key: "value",
+  },
+});
+```

package/.docs/raw/reference/client-js/tools.mdx

@@ -0,0 +1,44 @@
+# Tools API
+
+The Tools API provides methods to interact with and execute tools available in the Mastra platform.
+
+## Getting All Tools
+
+Retrieve a list of all available tools:
+
+```typescript
+const tools = await client.getTools();
+```
+
+## Working with a Specific Tool
+
+Get an instance of a specific tool:
+
+```typescript
+const tool = client.getTool("tool-id");
+```
+
+## Tool Methods
+
+### Get Tool Details
+
+Retrieve detailed information about a tool:
+
+```typescript
+const details = await tool.details();
+```
+
+### Execute Tool
+
+Execute a tool with specific arguments:
+
+```typescript
+const result = await tool.execute({
+  args: {
+    param1: "value1",
+    param2: "value2",
+  },
+  threadId: "thread-1", // Optional: Thread context
+  resourceid: "resource-1", // Optional: Resource identifier
+});
+```

package/.docs/raw/reference/client-js/vectors.mdx

@@ -0,0 +1,79 @@
+# Vectors API
+
+The Vectors API provides methods to work with vector embeddings for semantic search and similarity matching in Mastra.
+
+## Working with Vectors
+
+Get an instance of a vector store:
+
+```typescript
+const vector = client.getVector("vector-name");
+```
+
+## Vector Methods
+
+### Get Vector Index Details
+
+Retrieve information about a specific vector index:
+
+```typescript
+const details = await vector.details("index-name");
+```
+
+### Create Vector Index
+
+Create a new vector index:
+
+```typescript
+const result = await vector.createIndex({
+  indexName: "new-index",
+  dimension: 128,
+  metric: "cosine", // 'cosine', 'euclidean', or 'dotproduct'
+});
+```
+
+### Upsert Vectors
+
+Add or update vectors in an index:
+
+```typescript
+const ids = await vector.upsert({
+  indexName: "my-index",
+  vectors: [
+    [0.1, 0.2, 0.3], // First vector
+    [0.4, 0.5, 0.6], // Second vector
+  ],
+  metadata: [{ label: "first" }, { label: "second" }],
+  ids: ["id1", "id2"], // Optional: Custom IDs
+});
+```
+
+### Query Vectors
+
+Search for similar vectors:
+
+```typescript
+const results = await vector.query({
+  indexName: "my-index",
+  queryVector: [0.1, 0.2, 0.3],
+  topK: 10,
+  filter: { label: "first" }, // Optional: Metadata filter
+  includeVector: true, // Optional: Include vectors in results
+});
+```
+
+### Get All Indexes
+
+List all available indexes:
+
+```typescript
+const indexes = await vector.getIndexes();
+```
+
+### Delete Index
+
+Delete a vector index:
+
+```typescript
+const result = await vector.delete("index-name");
+```

package/.docs/raw/reference/client-js/workflows.mdx

@@ -0,0 +1,136 @@
+# Workflows API
+
+The Workflows API provides methods to interact with and execute automated workflows in Mastra.
+
+## Getting All Workflows
+
+Retrieve a list of all available workflows:
+
+```typescript
+const workflows = await client.getWorkflows();
+```
+
+## Working with a Specific Workflow
+
+Get an instance of a specific workflow:
+
+```typescript
+const workflow = client.getWorkflow("workflow-id");
+```
+
+## Workflow Methods
+
+### Get Workflow Details
+
+Retrieve detailed information about a workflow:
+
+```typescript
+const details = await workflow.details();
+```
+
+### Start workflow run asynchronously
+
+Start a workflow run with triggerData and await full run results:
+
+```typescript
+const {runId} = workflow.createRun()
+
+const result = await workflow.startAsync({
+  runId,
+  triggerData: {
+    param1: "value1",
+    param2: "value2",
+  },
+});
+```
+
+### Resume Workflow run asynchronously
+
+Resume a suspended workflow step and await full run result:
+
+```typescript
+const {runId} = createRun({runId: prevRunId})
+
+const result = await workflow.resumeAsync({
+  runId,
+  stepId: "step-id",
+  contextData: { key: "value" },
+});
+```
+
+### Watch Workflow
+
+Watch workflow transitions
+
+```typescript
+try{
+  // Get workflow instance
+  const workflow = client.getWorkflow("workflow-id");
+
+  // Create a workflow run
+  const {runId} = workflow.createRun()
+
+  // Watch workflow run 
+     workflow.watch({runId},(record)=>{
+       // Every new record is the latest transition state of the workflow run
+
+        console.log({
+          activePaths: record.activePaths,
+          results: record.results,
+          timestamp: record.timestamp,
+          runId: record.runId
+        });
+     });
+
+  // Start workflow run
+     workflow.start({
+      runId,
+      triggerData: {
+        city: 'New York',
+      },
+    });
+}catch(e){
+  console.error(e);
+}
+```
+### Resume Workflow
+
+Resume workflow run and watch workflow step transitions
+
+```typescript
+try{
+  //To resume a workflow run, when a step is suspended
+  const {run} = createRun({runId: prevRunId})
+
+  //Watch run
+   workflow.watch({runId},(record)=>{
+   // Every new record is the latest transition state of the workflow run
+
+        console.log({
+          activePaths: record.activePaths,
+          results: record.results,
+          timestamp: record.timestamp,
+          runId: record.runId
+        });
+   })
+
+   //resume run
+   workflow.resume({
+      runId,
+      stepId: "step-id",
+      contextData: { key: "value" },
+    });
+}catch(e){
+  console.error(e);
+}
+```
+
+### Workflow run result
+A workflow run result yields the following:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `activePaths` | `Record<string, { status: string; suspendPayload?: any; stepPath: string[] }>` | Currently active paths in the workflow with their execution status |
+| `results` | `CoreWorkflowRunResult<any, any, any>['results']` | Results from the workflow execution |
+| `timestamp` | `number` | Unix timestamp of when this transition occurred |
+| `runId` | `string` | Unique identifier for this workflow run instance |