@mastra/mcp-docs-server 0.10.1-alpha.1 → 0.11.0

package/.docs/organized/changelogs/%40mastra%2Fmcp-docs-server.md

@@ -1,5 +1,11 @@
 # @mastra/mcp-docs-server
 
+## 0.11.0-alpha.2
+
+### Minor Changes
+
+- 3240a80: feat: add mastra interactive course
+
 ## 0.10.1-alpha.1
 
 ### Patch Changes
@@ -293,10 +299,4 @@
   - @mastra/core@0.9.2-alpha.2
   - @mastra/mcp@0.4.2-alpha.2
 
-## 0.0.12-alpha.1
-
-### Patch Changes
-
-- Updated dependencies [b804723]
-
-... 599 more lines hidden. See full changelog in package directory.
+... 605 more lines hidden. See full changelog in package directory.

package/.docs/organized/changelogs/mastra.md

@@ -1,5 +1,11 @@
 # mastra
 
+## 0.10.1-alpha.6
+
+### Patch Changes
+
+- 3240a80: feat: add vscode as option to interactive prompt
+
 ## 0.10.1-alpha.5
 
 ### Patch Changes
@@ -293,10 +299,4 @@
 
 ### Patch Changes
 
-- 0db0992: - add new --mcp option to cli
-  - add support for mcp in vscode
-  - include examples with --default flag
-- b5d2de0: In vNext workflow serializedStepGraph, return only serializedStepFlow for steps created from a workflow
-  allow viewing inner nested workflows in a multi-layered nested vnext workflow on the playground
-
-... 3351 more lines hidden. See full changelog in package directory.
+... 3357 more lines hidden. See full changelog in package directory.

package/.docs/raw/course/01-first-agent/01-introduction-to-mastra.md

@@ -0,0 +1,21 @@
+# Getting Started with Mastra
+
+Welcome to the first step of building your first Mastra agent! In this lesson, you'll learn how to create a simple agent that can read data from a public Google Sheet using a custom tool function.
+
+## What is an Agent?
+
+An agent is software with non-deterministic code that can make autonomous decisions based on inputs and environment rather than following fixed, predictable instructions every time.
+
+Agents are AI systems that can:
+
+- Perceive their environment through various inputs
+- Make decisions based on those inputs
+- Take actions to accomplish specific goals
+- Learn and adapt their behavior over time
+
+The best agents use several important features:
+
+1. **Memory**: They remember past interactions and learn from them
+2. **Planning**: They can break down complex tasks into smaller steps
+3. **Tool use**: They can leverage external tools and APIs to expand their capabilities
+4. **Feedback loops**: They can evaluate their own performance and adjust accordingly

package/.docs/raw/course/01-first-agent/02-what-is-mastra.md

@@ -0,0 +1,11 @@
+# What is Mastra?
+
+[Mastra](https://github.com/mastra-ai/mastra) is an open-source AI Agent Framework for TypeScript that includes all the basic primitives for AI engineering right out of the box:
+
+- Agents with tools, memory, and tracing
+- State-machine based workflows
+- Evals for tracking and measuring AI output
+- Storage for RAG pipelines
+- Local development playground
+
+With Mastra, you can quickly build, test, and deploy AI agents that can perform a wide variety of tasks. The framework is designed to be modular and extensible, allowing you to add new capabilities as needed.

package/.docs/raw/course/01-first-agent/03-verifying-installation.md

@@ -0,0 +1,18 @@
+# Verifying Your Mastra Installation
+
+Before we begin building our agent, let's make sure you have Mastra properly installed. First, let's check if @mastra/core is in the package.json and there is a src/mastra directory. If so, you can skip this step.
+
+If you haven't installed Mastra yet, you can do so by running:
+
+```bash
+npm create mastra@latest
+```
+
+If you do need to install mastra, follow the on-screen prompts and make sure to:
+
+- Opt-in to installing both Agents and Workflows
+- Say yes to installing tools
+- Select OpenAI, Anthropic, or Google for your model
+- Say yes to adding an example
+
+You'll also need to add your OpenAI, Anthropic, or Google API key to the project.

package/.docs/raw/course/01-first-agent/04-project-structure.md

@@ -0,0 +1,12 @@
+# Verifying Project Structure
+
+Let's check that your project has the correct structure. You should have:
+
+1. A `src/mastra` directory that contains:
+   - `index.ts` - The main entry point for your Mastra project
+   - `agents/index.ts` - Where your agents are defined
+   - `tools/index.ts` - Where your tools are defined
+
+If these files exist, you're ready to start building your agent!
+
+This structure is important because it follows the Mastra convention for organizing your code. The `index.ts` file is the main entry point for your Mastra project, while the `agents` and `tools` directories contain the definitions for your agents and tools, respectively.

package/.docs/raw/course/01-first-agent/05-running-playground.md

@@ -0,0 +1,19 @@
+# Running the Playground
+
+To test your agent as you build it, you'll need to run the Mastra playground:
+
+```bash
+npm run dev
+```
+
+This will start the playground at `http://localhost:4111/`, where you can interact with your agent and test its capabilities.
+
+The playground provides a user-friendly interface for testing your agent, allowing you to:
+
+- Send messages to your agent
+- See the agent's responses
+- View the agent's thought process
+- Test tools directly
+- Debug any issues that arise
+
+In the next step, we'll create our first agent with a simple system prompt and test it in the playground.

package/.docs/raw/course/01-first-agent/06-understanding-system-prompts.md

@@ -0,0 +1,13 @@
+# Understanding System Prompts
+
+A good system prompt is crucial as it defines your agent's purpose, capabilities, and behavioral guidelines. It's the foundation that shapes how your agent will interact with users.
+
+A well-crafted system prompt should include:
+
+- **Role definition**: What the agent is and what it does
+- **Core capabilities**: What tasks the agent can perform
+- **Behavioral guidelines**: How the agent should respond and interact
+- **Constraints**: What the agent should not do or discuss
+- **Success criteria**: What makes the agent's responses good
+
+The system prompt acts as a set of instructions that guide the agent's behavior. It helps the agent understand its purpose and how it should interact with users. A clear and comprehensive system prompt will result in more consistent and helpful agent responses.

package/.docs/raw/course/01-first-agent/07-creating-your-agent.md

@@ -0,0 +1,49 @@
+# Creating Your Agent
+
+Let's create a simple agent that will help users analyze financial transaction data. We'll start by modifying the `agents/index.ts` file.
+
+First, make sure you have the necessary imports at the top of your file:
+
+```typescript
+import { Agent } from "@mastra/core";
+import { openai } from "@ai-sdk/openai";
+// We'll import our tool in a later step
+```
+
+Now, let's create our agent:
+
+```typescript
+export const financialAgent = new Agent({
+  name: "Financial Assistant Agent",
+  instructions: `ROLE DEFINITION
+- You are a financial assistant that helps users analyze their transaction data.
+- Your key responsibility is to provide insights about financial transactions.
+- Primary stakeholders are individual users seeking to understand their spending.
+
+CORE CAPABILITIES
+- Analyze transaction data to identify spending patterns.
+- Answer questions about specific transactions or vendors.
+- Provide basic summaries of spending by category or time period.
+
+BEHAVIORAL GUIDELINES
+- Maintain a professional and friendly communication style.
+- Keep responses concise but informative.
+- Always clarify if you need more information to answer a question.
+- Format currency values appropriately.
+- Ensure user privacy and data security.
+
+CONSTRAINTS & BOUNDARIES
+- Do not provide financial investment advice.
+- Avoid discussing topics outside of the transaction data provided.
+- Never make assumptions about the user's financial situation beyond what's in the data.
+
+SUCCESS CRITERIA
+- Deliver accurate and helpful analysis of transaction data.
+- Achieve high user satisfaction through clear and helpful responses.
+- Maintain user trust by ensuring data privacy and security.`,
+  model: openai("gpt-4o"), // You can use "gpt-3.5-turbo" if you prefer
+  tools: {}, // We'll add tools in a later step
+});
+```
+
+This creates a financial assistant agent with a well-defined system prompt that outlines its role, capabilities, behavioral guidelines, constraints, and success criteria.

package/.docs/raw/course/01-first-agent/08-exporting-your-agent.md

@@ -0,0 +1,18 @@
+# Exporting Your Agent
+
+To make your agent available to the playground, you need to export it through the Mastra class in your `src/mastra/index.ts` file:
+
+```typescript
+import { Mastra } from "@mastra/core";
+import { financialAgent } from "./agents";
+
+export const mastra: Mastra = new Mastra({
+  agents: {
+    financialAgent,
+  },
+});
+```
+
+This creates a new Mastra instance that includes your financial agent, making it available to the playground and any other parts of your application.
+
+The Mastra class is the main entry point for your Mastra project. It's responsible for registering your agents and making them available to the rest of your application. By adding your agent to the Mastra instance, you're telling Mastra that this agent should be available for use.

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

@@ -0,0 +1,12 @@
+# Testing Your Agent
+
+Now let's test our 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 should see your "Financial Assistant Agent" in the list of agents
+4. Try sending a message like "Hello, can you help me analyze my spending?"
+
+At this point, your agent can respond to basic questions but doesn't have access to any transaction data. In the next step, we'll create a custom tool to fetch transaction data from a Google Sheet.
+
+Testing your agent in the playground is an important step in the development process. It allows you to see how your agent responds to different inputs and identify any issues that need to be addressed before deploying it to production.

package/.docs/raw/course/01-first-agent/10-understanding-tools.md

@@ -0,0 +1,14 @@
+# Understanding Tools in Mastra
+
+Tools in Mastra are functions that your agent can call to perform specific tasks. They extend your agent's capabilities by giving it access to external data sources, APIs, and functionality beyond what's available in the language model itself.
+
+Each tool has:
+
+- A unique ID that the agent uses to reference it
+- A clear description of what it does, which helps the agent understand when to use it
+- Input and output schemas that define the expected parameters and return values
+- An execute function that performs the actual work
+
+Tools are a powerful way to enhance your agent's abilities. They allow your agent to interact with the outside world, access specific data sources, and perform actions that would otherwise be impossible for a language model alone.
+
+In the next step, we'll create a custom tool that fetches transaction data from a Google Sheet.

package/.docs/raw/course/01-first-agent/11-creating-transactions-tool.md

@@ -0,0 +1,39 @@
+# Creating the getTransactions Tool
+
+Let's create a tool that fetches transaction data from a Google Sheet. We'll add this to your `tools/index.ts` file.
+
+First, make sure you have the necessary imports:
+
+```typescript
+import { createTool } from "@mastra/core";
+import { z } from "zod";
+```
+
+Now, let's create our tool:
+
+```typescript
+export const getTransactionsTool = createTool({
+  id: "get-transactions",
+  description: "Get transaction data from Google Sheets",
+  inputSchema: z.object({}), // No input parameters needed
+  outputSchema: z.object({
+    csvData: z.string(),
+  }),
+  execute: async () => {
+    return await getTransactions();
+  },
+});
+
+const getTransactions = async () => {
+  // This URL points to a public Google Sheet with transaction data
+  const url =
+    "https://docs.google.com/spreadsheets/d/e/2PACX-1vTQWaCzJAFsF4owWRHQRLo4G0-ERv31c74OOZFnqLiTLaP7NweoiX7IXvzQud2H6bdUPnIqZEA485Ux/pubhtml?gid=0&single=true";
+  const response = await fetch(url);
+  const data = await response.text();
+  return {
+    csvData: data,
+  };
+};
+```
+
+This tool fetches transaction data from a public Google Sheet and returns it as a string. The `createTool` function from Mastra makes it easy to define the tool's ID, description, input and output schemas, and execution logic.

package/.docs/raw/course/01-first-agent/12-connecting-tool-to-agent.md

@@ -0,0 +1,29 @@
+# Connecting the Tool to Your Agent
+
+Now that we've created our tool, we need to connect it to our agent. Go back to your `agents/index.ts` file and update it:
+
+1. Import the tool:
+
+```typescript
+import { getTransactionsTool } from "../tools";
+```
+
+2. Add the tool to your agent:
+
+```typescript
+export const financialAgent = new Agent({
+  name: "Financial Assistant Agent",
+  instructions: `ROLE DEFINITION
+  // ... existing instructions ...
+  
+  TOOLS
+  - Use the getTransactions tool to fetch financial transaction data.
+  - Analyze the transaction data to answer user questions about their spending.`,
+  model: openai("gpt-4o"),
+  tools: { getTransactionsTool }, // Add our tool here
+});
+```
+
+By adding the tool to your agent's configuration, you're making it available for the agent to use. The agent will now be able to call the `getTransactions` tool when it needs to access transaction data.
+
+It's also important to update the agent's instructions to include information about the tool. This helps the agent understand when and how to use the tool to fulfill user requests.

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

@@ -0,0 +1,15 @@
+# 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/14-understanding-memory.md

@@ -0,0 +1,14 @@
+# Understanding Memory in Agents
+
+Memory is a crucial component for creating more natural and context-aware agents. It allows your agent to maintain context across multiple interactions with users.
+
+Memory allows your agent to:
+
+- Remember previous user questions and its own responses
+- Maintain context across multiple interactions
+- Provide more personalized and relevant responses
+- Avoid asking for the same information repeatedly
+
+Without memory, your agent would treat each interaction as if it were the first, leading to a disjointed and frustrating user experience. With memory, your agent can build on previous conversations, creating a more natural and helpful interaction.
+
+In the following steps, we'll add memory to our financial assistant agent to make it more context-aware and capable of providing better responses over time.

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

@@ -0,0 +1,11 @@
+# Installing Memory
+
+First, we need to install the Mastra memory package to add memory capabilities to our agent. Run the following command in your terminal:
+
+```bash
+npm install @mastra/memory
+```
+
+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.
+
+This package is 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

@@ -0,0 +1,28 @@
+# 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 class:
+
+```typescript
+import { Agent } from "@mastra/core";
+import { openai } from "@ai-sdk/openai";
+import { Memory } from "@mastra/memory";
+import { getTransactionsTool } from "../tools";
+```
+
+2. Add memory to your agent:
+
+```typescript
+export const financialAgent = new Agent({
+  name: "Financial Assistant Agent",
+  instructions: `ROLE DEFINITION
+  // ... existing instructions ...
+  `,
+  model: openai("gpt-4o"),
+  tools: { getTransactionsTool },
+  memory: new Memory(), // 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.

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

@@ -0,0 +1,15 @@
+# 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/01-first-agent/18-conclusion.md

@@ -0,0 +1,20 @@
+# Congratulations!
+
+You've successfully built your first Mastra agent with:
+
+- A well-defined system prompt
+- A custom tool for fetching transaction data
+- Memory for maintaining context across conversations
+
+This is just the beginning of what you can do with Mastra. Here are some ways you could extend your agent:
+
+- Add more tools or use MCP to expand its capabilities (we will cover this in the next lesson)
+- Implement more sophisticated memory storage
+- Create a workflow that combines multiple agents
+- Deploy your agent to a production environment
+
+For more information and advanced features, check out the [Mastra documentation](https://mastra.ai/docs).
+
+## Next Steps
+
+In the next lesson, you'll learn how to integrate MCP (Model Context Protocol) servers with your Mastra agent to expand its capabilities even further. MCP servers allow your agent to access external data sources and APIs, making it even more powerful and versatile.

package/.docs/raw/course/02-agent-tools-mcp/01-introduction-to-mcp.md

@@ -0,0 +1,15 @@
+# Installing and Setting Up MCP
+
+In this lesson, we'll learn how to enhance your Mastra agent with MCP (Model Context Protocol) servers. MCP allows your agent to access a wide range of external tools and services without having to write custom tool functions for each one.
+
+## What is MCP?
+
+MCP (Model Context Protocol) is a standard that allows AI models to access external tools and services through a consistent interface. By integrating MCP servers with your Mastra agent, you can give it access to:
+
+- Email services like Gmail
+- Code repositories like GitHub
+- Social media platforms
+- Weather information
+- News sources
+- File systems
+- And many more services

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

@@ -0,0 +1,11 @@
+# Installing MCP
+
+First, let's install the Mastra MCP package:
+
+```bash
+npm install @mastra/mcp
+```
+
+The `@mastra/mcp` package provides the necessary infrastructure to connect your Mastra agent to various MCP servers. This package handles the communication between your agent and the MCP servers, allowing your agent to access the tools and services provided by those servers.
+
+Installing this package is the first step in enhancing your agent with MCP capabilities. Once installed, you'll need to configure it to connect to specific MCP servers, which we'll cover in the next steps.

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

@@ -0,0 +1,21 @@
+# 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 { MCPConfiguration } from "@mastra/mcp";
+```
+
+Then, create a basic MCP configuration object:
+
+```typescript
+const mcp = new MCPConfiguration({
+  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

@@ -0,0 +1,11 @@
+# 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

@@ -0,0 +1,20 @@
+# 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/06-testing-mcp-setup.md

@@ -0,0 +1,12 @@
+# Testing Your Setup
+
+At this point, your agent doesn't have any MCP servers configured yet, but the basic setup is in place. Let's test that everything is working:
+
+1. Make sure your development server is running with `npm run dev`
+2. Open the playground at http://localhost:4111/
+3. You should see your "Personal Assistant" agent in the list of agents
+4. Try sending a message like "Hello, what can you help me with?"
+
+The agent should respond, but it won't have any special capabilities yet. In the next steps, we'll add various MCP servers to give your agent powerful new abilities.
+
+In the next step, we'll add the Zapier MCP server to give your agent access to email and social media tools.

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

@@ -0,0 +1,14 @@
+# 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

@@ -0,0 +1,16 @@
+# 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

@@ -0,0 +1,17 @@
+# 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 MCPConfiguration({
+  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

@@ -0,0 +1,29 @@
+# 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/11-testing-zapier-integration.md

@@ -0,0 +1,13 @@
+# Testing the Zapier Integration
+
+Let's test the Zapier integration:
+
+1. Make sure your development server is running with `npm run dev`
+2. Open the playground at http://localhost:4111/
+3. Try asking your agent to perform tasks that use Zapier, such as:
+   - "Get my last email"
+   - "Send an email to youremail@gmail.com with the subject 'Test' and body 'Hello, this is a test email'"
+
+If everything is set up correctly, your agent should be able to use the Zapier tools to perform these tasks.
+
+Testing your integration is an important step to ensure that your agent can properly access and use the Zapier tools. When you ask your agent to perform a task that requires Zapier, it should recognize the need to use the appropriate Zapier tool and make the necessary API calls to complete the task.

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

@@ -0,0 +1,17 @@
+# 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.