@mastra/mcp-docs-server 0.0.0-error-handler-fix-20251020202607 → 0.0.0-execa-dynamic-import-20260304221256

package/.docs/raw/course/01-first-agent/13-testing-your-tool.md

@@ -1,15 +0,0 @@
-# Testing Your Tool
-
-Let's test our tool and agent in the playground:
-
-1. Make sure your development server is running with `npm run dev`
-2. Open the playground at http://localhost:4111/
-3. You can test the tool directly in the Tools tab to make sure it's working
-4. Then, try asking your agent questions like:
-   - "Can you show me my recent transactions?"
-   - "How much did I spend on Amazon?"
-   - "What was my largest transaction this month?"
-
-Your agent should now be able to fetch the transaction data and answer questions about it. However, it doesn't yet have memory, so it won't remember previous conversations. We'll add that in the next step.
-
-Testing your tool directly in the playground is a great way to verify that it's working correctly before integrating it with your agent. This helps you identify and fix any issues with the tool itself before troubleshooting potential issues with the agent's use of the tool.

package/.docs/raw/course/01-first-agent/15-installing-memory.md

@@ -1,13 +0,0 @@
-# Installing Memory
-
-First, we need to install the Mastra memory package to add memory capabilities to our agent. We also install a storage adapter to persist the memory data. We will use the `libsql` storage adapter. Run the following command in your terminal:
-
-```bash
-npm install @mastra/memory @mastra/libsql
-```
-
-The `@mastra/memory` package provides a simple yet powerful memory system for your Mastra agents. It allows your agent to remember previous conversations and maintain context across multiple interactions.
-
-The `@mastra/libsql` package is one of many storage adapters that persists the memory data to an `SQLite` database.
-
-These packages are separate from the core Mastra package to keep the framework modular and allow you to only include the features you need in your project.

package/.docs/raw/course/01-first-agent/16-adding-memory-to-agent.md

@@ -1,33 +0,0 @@
-# Adding Memory to Your Agent
-
-Now, let's update our agent to include memory. Open your `agents/index.ts` file and make the following changes:
-
-1. Import the Memory and LibSQLStore classes:
-
-```typescript
-import { Agent } from "@mastra/core";
-import { openai } from "@ai-sdk/openai";
-import { Memory } from "@mastra/memory";
-import { LibSQLStore } from "@mastra/libsql";
-import { getTransactionsTool } from "../tools";
-```
-
-2. Add memory to your agent configured by a storage instance:
-
-```typescript
-export const financialAgent = new Agent({
-  name: "Financial Assistant Agent",
-  instructions: `ROLE DEFINITION
-  // ... existing instructions ...
-  `,
-  model: openai("gpt-4o"),
-  tools: { getTransactionsTool },
-  memory: new Memory({
-    storage: new LibSQLStore({
-      url: "file:../../memory.db", // local file-system database. Location is relative to the output directory `.mastra/output`
-    }),
-  }), // Add memory here
-});
-```
-
-By adding the `memory` property to your agent configuration, you're enabling it to remember previous conversations. The `Memory` class from the `@mastra/memory` package provides a simple way to add memory capabilities to your agent. The `LibSQLStore` class from `@mastra/libsql` persists the memory data to a `SQLite` database.

package/.docs/raw/course/01-first-agent/17-testing-memory.md

@@ -1,15 +0,0 @@
-# Testing Your Agent with Memory
-
-Let's test our agent's memory capabilities in the playground:
-
-1. Make sure your development server is running with `npm run dev`
-2. Open the playground at http://localhost:4111/
-3. Start a conversation with your agent by asking about transactions
-4. Then, ask a follow-up question that references the previous conversation, like:
-   - "What was that largest transaction again?"
-   - "Can you categorize those Amazon purchases we talked about?"
-   - "How does my spending this month compare to what you showed me earlier?"
-
-Your agent should now be able to remember previous conversations and provide more contextual responses.
-
-With memory enabled, your agent can now maintain context across multiple interactions, creating a more natural and helpful user experience. This is especially important for financial assistants, where users may want to refer back to previous information or build on earlier conversations.

package/.docs/raw/course/02-agent-tools-mcp/03-setting-up-mcp-configuration.md

@@ -1,21 +0,0 @@
-# Setting Up MCP Configuration
-
-Now, let's create a basic MCP configuration in your agent file. Open your `src/mastra/agents/index.ts` file and add the following imports:
-
-```typescript
-import { MCPClient } from "@mastra/mcp";
-```
-
-Then, create a basic MCP configuration object:
-
-```typescript
-const mcp = new MCPClient({
-  servers: {
-    // We'll add servers in the next steps
-  },
-});
-```
-
-This configuration object will be used to specify which MCP servers your agent should connect to. The `servers` property is an object where each key is a unique identifier for a server, and the value contains the configuration for that server.
-
-In the upcoming steps, we'll add various MCP servers to this configuration, giving your agent access to a wide range of tools and services.

package/.docs/raw/course/02-agent-tools-mcp/04-initializing-mcp-tools.md

@@ -1,11 +0,0 @@
-# Initializing MCP Tools
-
-Once you have the configuration set up, you need to initialize the MCP tools:
-
-```typescript
-const mcpTools = await mcp.getTools();
-```
-
-This asynchronous call fetches all the available tools from the configured MCP servers. The `getTools()` method connects to each server specified in your configuration, retrieves the available tools, and returns them in a format that can be used by your Mastra agent.
-
-The `mcpTools` object will contain all the tools provided by the MCP servers you've configured. We'll add these tools to our agent in the next step.

package/.docs/raw/course/02-agent-tools-mcp/05-updating-your-agent.md

@@ -1,20 +0,0 @@
-# Updating Your Agent
-
-Let's update your agent to use the MCP tools. Modify your agent definition to include the MCP tools:
-
-```typescript
-export const personalAssistantAgent = new Agent({
-  name: "Personal Assistant",
-  instructions: `
-    You are a helpful personal assistant that can help with various tasks.
-    
-    Keep your responses concise and friendly.
-  `,
-  model: openai("gpt-4o"),
-  tools: { ...mcpTools }, // Add MCP tools to your agent
-});
-```
-
-By spreading the `mcpTools` object into your agent's `tools` property, you're making all the tools from your configured MCP servers available to your agent. This allows your agent to access and use these tools when responding to user requests.
-
-As we add more MCP servers in the upcoming steps, the `mcpTools` object will automatically include tools from those servers as well, giving your agent an expanding set of capabilities.

package/.docs/raw/course/02-agent-tools-mcp/07-what-is-zapier-mcp.md

@@ -1,14 +0,0 @@
-# Adding the Zapier MCP Server
-
-In this step, we'll add the Zapier MCP server to our agent, which will give it access to email, social media, and many other integrations available through Zapier.
-
-## What is Zapier MCP?
-
-Zapier MCP is a server that provides access to thousands of apps and services through the Zapier platform. This includes:
-
-- Email services (Gmail, Outlook, etc.)
-- Social media platforms (Twitter/X, LinkedIn, etc.)
-- Project management tools (Trello, Asana, etc.)
-- And many more
-
-By integrating the Zapier MCP server with your Mastra agent, you can give it access to all these services without having to write custom tool functions for each one. This significantly expands your agent's capabilities and makes it more useful for a wide range of tasks.

package/.docs/raw/course/02-agent-tools-mcp/08-getting-zapier-mcp-url.md

@@ -1,16 +0,0 @@
-# Getting a Zapier MCP URL
-
-First, you'll need to get a Zapier MCP URL. This typically requires:
-
-1. Creating a Zapier account if you don't have one
-2. Setting up the Zapier MCP integration by adding some tools (we will use Gmail in this example)
-3. Getting your unique MCP URL
-
-For this example, we'll use an environment variable to store the URL:
-
-```bash
-# Add this to your .env file
-ZAPIER_MCP_URL=https://your-zapier-mcp-url.zapier.app
-```
-
-Using an environment variable is a good practice for storing sensitive information like API URLs. It keeps the URL out of your code, making it easier to manage and more secure. It also allows you to use different URLs for different environments (development, staging, production) without changing your code.

package/.docs/raw/course/02-agent-tools-mcp/09-updating-mcp-config-zapier.md

@@ -1,17 +0,0 @@
-# Updating Your MCP Configuration
-
-Now, let's update your MCP configuration in `src/mastra/agents/index.ts` to include the Zapier server:
-
-```typescript
-const mcp = new MCPClient({
-  servers: {
-    zapier: {
-      url: new URL(process.env.ZAPIER_MCP_URL || ""),
-    },
-  },
-});
-```
-
-This configuration tells your agent how to connect to the Zapier MCP server. The `zapier` key is a unique identifier for this server in your configuration, and the `url` property specifies the URL of the Zapier MCP server.
-
-The `new URL()` constructor creates a URL object from the string provided by the environment variable. The `|| ""` part provides a default empty string in case the environment variable is not set, which prevents your application from crashing if the environment variable is missing.

package/.docs/raw/course/02-agent-tools-mcp/10-updating-agent-instructions-zapier.md

@@ -1,29 +0,0 @@
-# Updating Your Agent's Instructions
-
-Next, let's update your agent's instructions to include information about the Zapier tools:
-
-```typescript
-export const personalAssistantAgent = new Agent({
-  name: "Personal Assistant",
-  instructions: `
-    You are a helpful personal assistant that can help with various tasks such as email 
-    and scheduling social media posts.
-    
-    You have access to the following tools:
-    
-    1. Gmail:
-       - Use these tools for reading and categorizing emails from Gmail
-       - You can categorize emails by priority, identify action items, and summarize content
-       - You can also use this tool to send emails
-    
-    Keep your responses concise and friendly.
-  `,
-  model: openai("gpt-4o"),
-  tools: { ...mcpTools },
-  memory,
-});
-```
-
-Updating your agent's instructions is crucial for helping it understand when and how to use the tools available to it. By explicitly mentioning the Gmail tools in the instructions, you're giving your agent context about what these tools do and when to use them.
-
-This helps the agent make better decisions about which tools to use when responding to user requests, resulting in more helpful and accurate responses.

package/.docs/raw/course/02-agent-tools-mcp/12-troubleshooting-zapier.md

@@ -1,17 +0,0 @@
-# Troubleshooting
-
-If your agent can't access the Zapier tools, check:
-
-1. That your Zapier MCP URL is correct in your environment variables
-2. That you've properly set up the Zapier MCP integration
-3. That the tools are properly loaded by checking the Tools tab in the playground
-
-Common issues include:
-
-- Incorrect or missing environment variables
-- Network connectivity problems
-- Authentication issues with the Zapier MCP server
-
-If you're having trouble, try restarting your development server after making changes to your environment variables or configuration. This ensures that the changes are properly loaded.
-
-In the next step, we'll add the GitHub MCP server to give your agent the ability to monitor and interact with GitHub repositories.

package/.docs/raw/course/02-agent-tools-mcp/13-what-is-github-mcp.md

@@ -1,14 +0,0 @@
-# Adding the GitHub MCP Server
-
-In this step, we'll add the Composio GitHub MCP server to our agent, which will give it the ability to monitor and interact with GitHub repositories.
-
-## What is the GitHub MCP Server?
-
-The GitHub MCP server provides tools for interacting with GitHub repositories, including:
-
-- Monitoring repository activity
-- Checking pull requests and issues
-- Viewing commit history
-- Summarizing development patterns
-
-By integrating the GitHub MCP server with your Mastra agent, you can create an assistant that helps you stay on top of your GitHub repositories, track important changes, and get insights into development activity. This is particularly useful for developers and teams who want to monitor their projects without constantly checking GitHub manually.

package/.docs/raw/course/02-agent-tools-mcp/14-getting-github-mcp-url.md

@@ -1,35 +0,0 @@
-# Getting a Smithery GitHub MCP URL
-
-First, you'll need to get a Smithery GitHub MCP URL. This typically requires:
-
-1. Setting up a Smithery account
-2. Creating a personal access token with your GitHub account
-3. Getting your unique MCP URL via the Smithery packages
-
-For this example, we'll use an environment variable to store the Smithery API key and profile name which can be found in the Smithery interface.
-
-```bash
-# Add this to your .env file
-SMITHERY_API_KEY=your_smithery_api_key
-SMITHERY_PROFILE=your_smithery_profile_name
-```
-
-Using an environment variable keeps your configuration secure and flexible. It also prevents sensitive information from being committed to your repository.
-
-We will use the Smithery packages to authenticate and create a streamable HTTP URL for the MCP server configuration
-
-```bash
-pnpm install @smithery/sdk
-```
-
-```ts
-import { createSmitheryUrl } from "@smithery/sdk";
-
-const smitheryGithubMCPServerUrl = createSmitheryUrl(
-  "https://server.smithery.ai/@smithery-ai/github",
-  {
-    apiKey: process.env.SMITHERY_API_KEY,
-    profile: process.env.SMITHERY_PROFILE,
-  },
-);
-```

package/.docs/raw/course/02-agent-tools-mcp/15-updating-mcp-config-github.md

@@ -1,20 +0,0 @@
-# Updating Your MCP Configuration
-
-Now, let's update your MCP configuration in `src/mastra/agents/index.ts` to include the GitHub server:
-
-```typescript
-const mcp = new MCPClient({
-  servers: {
-    zapier: {
-      url: new URL(process.env.ZAPIER_MCP_URL || ""),
-    },
-    github: {
-      url: smitheryGithubMCPServerUrl,
-    },
-  },
-});
-```
-
-This configuration adds the GitHub MCP server alongside the Zapier server we added in the previous step. The `github` key is a unique identifier for this server in your configuration, and the `url` property specifies the URL of the GitHub MCP server.
-
-By adding multiple servers to your MCP configuration, you're building a more versatile agent that can access a wider range of tools and services. Each server adds its own set of capabilities to your agent.

package/.docs/raw/course/02-agent-tools-mcp/16-updating-agent-instructions-github.md

@@ -1,33 +0,0 @@
-# Updating Your Agent's Instructions
-
-Next, let's update your agent's instructions to include information about the GitHub tools:
-
-```typescript
-export const personalAssistantAgent = new Agent({
-  name: "Personal Assistant",
-  instructions: `
-    You are a helpful personal assistant that can help with various tasks such as email, 
-    monitoring github activity, and scheduling social media posts.
-    
-    You have access to the following tools:
-    
-    1. Gmail:
-       - Use these tools for reading and categorizing emails from Gmail
-       - You can categorize emails by priority, identify action items, and summarize content
-       - You can also use this tool to send emails
-    
-    2. GitHub:
-       - Use these tools for monitoring and summarizing GitHub activity
-       - You can summarize recent commits, pull requests, issues, and development patterns
-    
-    Keep your responses concise and friendly.
-  `,
-  model: openai("gpt-4o"),
-  tools: { ...mcpTools },
-  memory,
-});
-```
-
-By updating your agent's instructions to include information about the GitHub tools, you're helping it understand when and how to use these tools. The instructions provide context about what the GitHub tools can do, such as monitoring repository activity, checking pull requests and issues, and summarizing development patterns.
-
-This context helps your agent make better decisions about when to use the GitHub tools and how to interpret the results they provide.

package/.docs/raw/course/02-agent-tools-mcp/18-troubleshooting-github.md

@@ -1,17 +0,0 @@
-# Troubleshooting
-
-If your agent can't access the GitHub tools, check:
-
-1. That your GitHub MCP URL is correct in your environment variables
-2. That you've properly authenticated with GitHub
-3. That the tools are properly loaded by checking the Tools tab in the playground
-
-Common issues include:
-
-- Incorrect or missing environment variables
-- Authentication issues with GitHub
-- Permission problems with the repositories you're trying to access
-
-If you're having trouble, try checking the console logs for any error messages related to the GitHub MCP server. These can provide valuable clues about what might be going wrong.
-
-In the next step, we'll add the Hacker News MCP server to give your agent access to tech news and discussions.

package/.docs/raw/course/02-agent-tools-mcp/20-updating-mcp-config-hackernews.md

@@ -1,26 +0,0 @@
-# Updating Your MCP Configuration
-
-Unlike the previous MCP servers that use URLs, the Hacker News MCP server can be run directly using NPX. This means we don't need to set up any external services or authentication.
-
-Let's update your MCP configuration in `src/mastra/agents/index.ts` to include the Hacker News server:
-
-```typescript
-const mcp = new MCPClient({
-  servers: {
-    zapier: {
-      url: new URL(process.env.ZAPIER_MCP_URL || ""),
-    },
-    github: {
-      url: new URL(process.env.COMPOSIO_MCP_GITHUB || ""),
-    },
-    hackernews: {
-      command: "npx",
-      args: ["-y", "@devabdultech/hn-mcp-server"],
-    },
-  },
-});
-```
-
-This configuration tells MCP to run the Hacker News server using NPX when needed. The `-y` flag automatically confirms any prompts, making it seamless to use.
-
-Unlike the Zapier and GitHub servers that connect to external services via URLs, the Hacker News server is run locally using NPX. This approach is simpler because it doesn't require any authentication or external service setup.

package/.docs/raw/course/02-agent-tools-mcp/21-updating-agent-instructions-hackernews.md

@@ -1,38 +0,0 @@
-# Updating Your Agent's Instructions
-
-Next, let's update your agent's instructions to include information about the Hacker News tools:
-
-```typescript
-export const personalAssistantAgent = new Agent({
-  name: "Personal Assistant",
-  instructions: `
-    You are a helpful personal assistant that can help with various tasks such as email, 
-    monitoring github activity, scheduling social media posts, and providing tech news.
-    
-    You have access to the following tools:
-    
-    1. Gmail:
-       - Use these tools for reading and categorizing emails from Gmail
-       - You can categorize emails by priority, identify action items, and summarize content
-       - You can also use this tool to send emails
-    
-    2. GitHub:
-       - Use these tools for monitoring and summarizing GitHub activity
-       - You can summarize recent commits, pull requests, issues, and development patterns
-    
-    3. Hackernews:
-       - Use this tool to search for stories on Hackernews
-       - You can use it to get the top stories or specific stories
-       - You can use it to retrieve comments for stories
-    
-    Keep your responses concise and friendly.
-  `,
-  model: openai("gpt-4o"),
-  tools: { ...mcpTools },
-  memory,
-});
-```
-
-By updating your agent's instructions to include information about the Hacker News tools, you're helping it understand when and how to use these tools. The instructions provide context about what the Hacker News tools can do, such as searching for stories, retrieving top stories, and accessing comments.
-
-This context helps your agent make better decisions about when to use the Hacker News tools and how to interpret the results they provide. When a user asks about tech news or specific topics on Hacker News, your agent will know to use these tools to provide relevant information.

package/.docs/raw/course/02-agent-tools-mcp/26-updating-mcp-config-filesystem.md

@@ -1,33 +0,0 @@
-# Updating Your MCP Configuration
-
-Now, let's update your MCP configuration in `src/mastra/agents/index.ts` to include the Filesystem server:
-
-```typescript
-import path from "path";
-
-const mcp = new MCPClient({
-  servers: {
-    zapier: {
-      url: new URL(process.env.ZAPIER_MCP_URL || ""),
-    },
-    github: {
-      url: new URL(process.env.COMPOSIO_MCP_GITHUB || ""),
-    },
-    hackernews: {
-      command: "npx",
-      args: ["-y", "@devabdultech/hn-mcp-server"],
-    },
-    textEditor: {
-      command: "pnpx",
-      args: [
-        `@modelcontextprotocol/server-filesystem`,
-        path.join(process.cwd(), "..", "..", "notes"), // relative to output directory
-      ],
-    },
-  },
-});
-```
-
-This configuration tells MCP to run the Filesystem server using PNPX, pointing it to the "notes" directory we created. The `path.join(process.cwd(), "notes")` ensures that the path is correct regardless of where the application is run from.
-
-The `textEditor` key is a unique identifier for this server in your configuration. The `command` property specifies that we want to use PNPX to run the server, and the `args` property provides the arguments to pass to PNPX, including the package name and the path to the notes directory.

package/.docs/raw/course/02-agent-tools-mcp/27-updating-agent-instructions-filesystem.md

@@ -1,45 +0,0 @@
-# Updating Your Agent's Instructions
-
-Next, let's update your agent's instructions to include information about the Filesystem tools:
-
-```typescript
-export const personalAssistantAgent = new Agent({
-  name: "Personal Assistant",
-  instructions: `
-    You are a helpful personal assistant that can help with various tasks such as email, 
-    monitoring github activity, scheduling social media posts, providing tech news,
-    and managing notes and to-do lists.
-    
-    You have access to the following tools:
-    
-    1. Gmail:
-       - Use these tools for reading and categorizing emails from Gmail
-       - You can categorize emails by priority, identify action items, and summarize content
-       - You can also use this tool to send emails
-    
-    2. GitHub:
-       - Use these tools for monitoring and summarizing GitHub activity
-       - You can summarize recent commits, pull requests, issues, and development patterns
-    
-    3. Hackernews:
-       - Use this tool to search for stories on Hackernews
-       - You can use it to get the top stories or specific stories
-       - You can use it to retrieve comments for stories
-    
-    4. Filesystem:
-       - You also have filesystem read/write access to a notes directory. 
-       - You can use that to store info for later use or organize info for the user.
-       - You can use this notes directory to keep track of to-do list items for the user.
-       - Notes dir: ${path.join(process.cwd(), "notes")}
-    
-    Keep your responses concise and friendly.
-  `,
-  model: openai("gpt-4o"),
-  tools: { ...mcpTools },
-  memory,
-});
-```
-
-By updating your agent's instructions to include information about the Filesystem tools, you're helping it understand when and how to use these tools. The instructions provide context about what the Filesystem tools can do, such as storing information for later use and keeping track of to-do list items.
-
-This context helps your agent make better decisions about when to use the Filesystem tools and how to organize the information it stores. The inclusion of the notes directory path in the instructions ensures that your agent knows exactly where it can read from and write to.

package/.docs/raw/course/02-agent-tools-mcp/31-enhancing-memory-configuration.md

@@ -1,76 +0,0 @@
-# Enhancing Memory Configuration
-
-Finally, let's enhance our memory configuration to make our agent even more helpful:
-
-```typescript
-import { LibSQLStore, LibSQLVector } from "@mastra/libsql";
-
-const memory = new Memory({
-  storage: new LibSQLStore({
-    url: "file:../../memory.db",
-  }),
-  vector: new LibSQLVector({
-    connectionUrl: "file:../../memory.db",
-  }),
-  embedder: openai.embedding("text-embedding-3-small"),
-  options: {
-    // Keep last 20 messages in context
-    lastMessages: 20,
-    // Enable semantic search to find relevant past conversations
-    semanticRecall: {
-      topK: 3,
-      messageRange: {
-        before: 2,
-        after: 1,
-      },
-    },
-    // Enable working memory to remember user information
-    workingMemory: {
-      enabled: true,
-      template: `
-      <user>
-         <first_name></first_name>
-         <username></username>
-         <preferences></preferences>
-         <interests></interests>
-         <conversation_style></conversation_style>
-       </user>`,
-    },
-  },
-});
-```
-
-And update the agent instructions to use this enhanced memory:
-
-```typescript
-export const personalAssistantAgent = new Agent({
-  name: "Personal Assistant",
-  instructions: `
-    // ... existing instructions ...
-    
-    You have access to conversation memory and can remember details about users.
-    When you learn something about a user, update their working memory using the appropriate tool.
-    This includes:
-    - Their interests
-    - Their preferences
-    - Their conversation style (formal, casual, etc.)
-    - Any other relevant information that would help personalize the conversation
-
-    Always maintain a helpful and professional tone.
-    Use the stored information to provide more personalized responses.
-  `,
-  model: openai("gpt-4o"),
-  tools: { ...mcpTools },
-  memory,
-});
-```
-
-This enhanced memory configuration gives your agent more sophisticated memory capabilities:
-
-1. **Conversation History**: The `lastMessages` option keeps the last 20 messages in context, allowing your agent to reference recent conversations.
-
-2. **Semantic Recall**: The `semanticRecall` option enables your agent to find relevant past conversations using semantic search, even if they happened a long time ago. For `semanticRecall` to work, you need to have a vector store and an embedder configured
-
-3. **Working Memory**: The `workingMemory` option allows your agent to remember specific information about users, such as their preferences and interests, and use that information to provide more personalized responses.
-
-By updating your agent's instructions to include information about these memory capabilities, you're helping it understand how to use them effectively to provide a better user experience.

package/.docs/raw/course/02-agent-tools-mcp/32-conclusion.md

@@ -1,17 +0,0 @@
-# Conclusion
-
-Congratulations! You've successfully enhanced your Mastra agent with MCP servers, giving it powerful capabilities including:
-
-1. Email and social media integration through Zapier
-2. GitHub monitoring through the Composio GitHub MCP server
-3. Tech news access through the Hacker News MCP server
-4. Local file management through the Filesystem MCP server
-5. Enhanced memory for personalized interactions
-
-Your agent is now a versatile personal assistant that can help with a wide range of tasks. Feel free to experiment with different MCP servers and configurations to further enhance your agent's capabilities.
-
-The power of MCP lies in its ability to connect your agent to a wide variety of external services and data sources without requiring you to write custom tool functions for each one. This modular approach makes it easy to add new capabilities to your agent as needed.
-
-As you continue to develop your Mastra agent, consider exploring other MCP servers and tools that might be useful for your specific use case. The Mastra ecosystem is constantly growing, with new tools and capabilities being added regularly.
-
-For more information on MCP and available servers, check out the [Mastra MCP documentation](https://mastra.ai/docs/agents/mcp-guide).

package/.docs/raw/course/03-agent-memory/03-installing-memory.md

@@ -1,13 +0,0 @@
-# Installing Memory
-
-Let's start by installing the Mastra memory package:
-
-```bash
-npm install @mastra/memory @mastra/libsql
-```
-
-The `@mastra/memory` package provides all the functionality you need to add memory capabilities to your Mastra agents. It includes support for conversation history, semantic recall, and working memory.
-
-The `@mastra/libsql` package is **one of many** storage adapters that complement the memory package. The purpose of a storage adapter is to provide a way to persist the memory data to a database or other storage system. The `@mastra/libsql` package provides a storage adapter for LibSQL, which is a fast, open-source fork of SQLite.
-
-These packages are separate from the core Mastra package, allowing you to only include them when you need memory capabilities in your project. This modular approach helps keep your project dependencies lean when you don't need all features.