Foundation: Building AI Memory with MCP and Cursor

Capture: Transforming Cursor AI Conversations into Persistent Knowledge

Streamline: Automating Cursor History Export with CLI Tools

Extract: Mining AI Insights from Chat Logs with MCP-Powered Analysis

Connect: Building Interconnected Knowledge Graphs with Foam and Cursor

Automate: Scripting AI Knowledge Creation with MCP CLI Tools

Ideate: From Daily Notes to Actionable Issues with Cursor

Context: Mastering Project Switching in Cursor's AI Memory System

Script: Creating Reusable AI Automation with MCP and Claude Code

Agent: Build a Custom Agent Mode in Cursor for Managing Notes

genai

MCP is an open protocol that standardizes how applications provide context to LLMs. Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect your devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools.

Unleash Claude’s raw power directly in your terminal. Search million-line codebases instantly. Turn hours-long workflows into a single command. Your tools. Your workflow. Your codebase, evolving at thought speed.

claude-code

Developer knowledge often lives in separate silos from the codebase. This course demonstrates how to create a unified workflow where your notes, ideas, and conversations directly feed into your development process. We will build a local, AI-queriable knowledge base using Markdown and the Model Context Protocol (MCP). You will learn to turn unstructured daily notes into structured data, like bug reports and feature requests, using custom AI prompts. We will then automate this entire pipeline, from capturing an idea to generating the corresponding project file, creating an efficient and repeatable system.

In this course, you will learn to:
* Centralize project knowledge in a local, AI-queriable Markdown system.
* Create a repeatable process for exporting and organizing past AI conversations.
* Connect unstructured daily notes to structured project tasks using custom prompts.
* Automate the creation of issues, features, and bug reports from your notes.
* Develop headless scripts that integrate these knowledge workflows into your terminal.
* Design and implement custom agents to make complex workflows easy to reuse.

AI coding assistants are incredibly powerful, but their memory is often ephemeral. They forget context between conversations, forcing you to repeat information and lose valuable insights. This lesson introduces `basic-memory`, a knowledge management system that solves this by allowing your AI assistant to build a persistent, local knowledge graph using simple Markdown files.

`basic-memory` integrates directly with Cursor via the Model Context Protocol (MCP), enabling your AI to read and write notes about your project. This creates a long-term memory that the AI can access and build upon over time, all stored as human-readable files right in your project directory.

## Workflow Demonstrated

*   **Install and Initialize:** Use a single command to install `basic-memory` and initialize a new memory store for your current project.
*   **Configure the MCP Server:** Create a simple `mcp.json` file in your `.cursor` directory to connect `basic-memory` to Cursor's tool system.
*   **Write to Memory:** Use a natural language prompt in Cursor to instruct the AI to create a new note, which `basic-memory` saves as a Markdown file.
*   **Read from Memory:** Ask the AI to retrieve and summarize existing notes, demonstrating its ability to access its long-term, project-specific knowledge.

## Key Benefits

*   **Persistent Knowledge:** Your AI can pick up conversations right where you left off, retaining context from previous interactions.
*   **Local-First & Human-Readable:** All knowledge is stored as structured Markdown files on your computer, which you can read and edit directly.
*   **Structured & Searchable:** The AI can read, write, and search through notes, effectively building a traversable knowledge graph for your project.
*   **Seamless Integration:** Works directly with Cursor (or any compatible LLM) through the Model Context Protocol (MCP), enabling powerful, stateful automation.

## Commands Used

Install the `basic-memory` tool.
~~~bash
uv tool install basic-memory
~~~

Check the available commands for the `basic-memory` CLI.
~~~bash
bm --help
~~~

Add a new `basic-memory` project, linking a name to a specific directory path for storing memories.
~~~bash
bm project add script-generator ~/dev/script-generator/memories
~~~

## MCP Configuration

Create a `.cursor/mcp.json` file and add the following configuration, replacing `your-project-name` with the name you used in the `project add` command (`script-generator` in this example).

~~~json
{
  "mcpServers": {
    "basic-memory": {
      "command": "uvx",
      "args": ["basic-memory", "--project", "script-generator", "mcp"]
    }
  }
}
~~~

## AI Prompts

A prompt to ask the AI to write a new note to its memory.
~~~markdown
Please use basic memory to write a hello world note.
~~~

A prompt to ask the AI to retrieve and summarize information from its memory.
~~~markdown
Using basic memory, please read all of the notes I've created so far and summarize them for me.
~~~

cursor


Don't let valuable context from past AI conversations disappear. This lesson walks you through a powerful workflow to save your Cursor chat history as structured Markdown files, making them part of your project's long-term memory. You'll learn how to export, organize, and tag your conversations so the AI can recall them later, providing deep context for new tasks and ensuring continuity in your work.

### Workflow demonstrated in this lesson:

*   Find and export a past conversation from the chat history.
*   Save the exported chat as a Markdown file in your `memories` directory.
*   Add YAML frontmatter to make the memory discoverable by the AI.
*   Prompt the AI to find and summarize the saved conversation to inform a new task.
*   Use a simple CLI command to ensure your memory database stays in sync with your files.

### Key benefits:

*   **Create a persistent knowledge base:** Turn ephemeral chats into permanent, searchable project assets.
*   **Provide deep context:** Give the AI a complete history of past decisions and implementations.
*   **Ensure consistency:** Avoid repeating yourself and help the AI build upon previous work.
*   **Simple management:** Easily organize memories as simple Markdown files within your project.

## Saving a Conversation as a Memory

The first step is to locate and export the conversation you want to save.

1.  Open the Agent/Chat panel and click the "Show Chat History" icon.
2.  Find the desired conversation and open it.
3.  Click the "..." menu and select "Export Chat".
4.  This will save the entire conversation as a Markdown file. You can then move this file into a dedicated folder, such as `memories/conversations`, to keep your project organized.

## Making the Memory Discoverable

For the AI to find this memory, you need to add YAML frontmatter to the top of the Markdown file. This provides essential metadata for the Basic Memory system.

~~~yaml
---
title: Prompt Builder Upgrade Implementation Plan
type: conversation
permalink: conversations/prompt-builder-upgrade-implementation-plan
---
~~~

## Recalling a Memory in a New Chat

Once the memory is saved and tagged, you can reference it in a new conversation. The AI will use its `search_notes` tool to find the relevant memory based on your prompt.

~~~markdown
Please use basic memory to find my conversation about the prompt builder and summarize it. We may want to rethink how we approach this.
~~~

The AI will find the memory file, read its contents, and provide a summary based on that past conversation, giving it the full context it needs to proceed.

## Keeping Memories in Sync

The Basic Memory system uses a local database to make searching efficient. If you manually add, edit, or remove memory files, you may need to re-sync the database. You can do this easily from the terminal.

See all available commands:
~~~bash
bm --help
~~~

To sync your Markdown files with the memory database:
~~~bash
bm sync
~~~


The default flow for exporting conversations from the Cursor AI editor can be clunky and disorganized. You have to manually export each conversation, and the resulting files lack a consistent naming scheme, making it difficult to build a persistent, searchable history of your important AI interactions.

This lesson introduces `cursor-history` (`chi`), a simple command-line tool built to solve this exact problem. It provides a streamlined interface to quickly find, export, and save your Cursor conversations with clean, organized, and timestamped filenames directly from your terminal.

By using `chi`, you can easily build a "memory" of important conversations right inside your project. This organized history can then be used as context for future AI agent tasks, creating a more powerful, efficient, and context-aware development workflow.

### Workflow Demonstrated

*   Install the `cursor-history` CLI tool via NPM.
*   Use `chi --select` to interactively search and find past conversations from the current workspace.
*   Export a selected conversation to a well-named markdown file.
*   Save the exported conversation into a project's `memories` or `conversations` folder.
*   Leverage the saved conversation as context for new AI agent tasks, such as summarizing a past troubleshooting session.

### Key Benefits

*   Quickly find and export conversations without leaving the terminal.
*   Creates organized, timestamped filenames based on the workspace and conversation title.
*   Builds a persistent, searchable knowledge base of your AI interactions within your project.
*   Improves context for future AI tasks by making past conversations easily accessible.

### Spoken Prompts

~~~markdown
Please use basic memory to find where I was troubleshooting server errors and summarize what it found.
~~~

### Terminal Commands

~~~bash
npm i -g @johnlindquist/cursor-history@latest
~~~

~~~bash
chi --select
~~~

~~~bash
chi
~~~

~~~bash
chi --help
~~~

AI chat logs are a goldmine of project context, decisions, and hard-won lessons. But this knowledge is often ephemeral, lost in the scrollback. This lesson demonstrates a powerful workflow to automatically extract and structure this information into a persistent, queryable knowledge base directly within your project.

By using a custom "extractor" prompt, you can teach an AI agent to read your conversations and organize the key takeaways into structured notes for `plans`, `knowledge`, `decisions`, and `lessons_learned`. This turns your chat history from a fleeting record into a lasting asset, ensuring you never lose valuable insights and can bootstrap future AI tasks with a rich, historical context.

## The Problem: Transient AI Knowledge

-   Valuable insights, architectural decisions, and solutions to problems are generated during AI conversations.
-   This knowledge is typically trapped in chat history, making it difficult to find and reuse later.
-   Without a system, you and your AI agent are prone to repeating past mistakes or re-solving the same problems.

## The Solution: Automated Knowledge Extraction

This workflow uses a master prompt to instruct an AI agent to act as a "knowledge extractor." The agent systematically reads a conversation transcript, identifies important information, and uses tools to create or update structured markdown files within a dedicated `memories` directory.

### How It Works

1.  **Create an Extractor Prompt:** A detailed markdown file (`extract-conversation.md`) instructs the agent on its goal: to scan a conversation for specific categories of information (plans, knowledge, decisions, lessons learned).
2.  **Define Memory Folders:** The prompt specifies the target directories where notes should be stored (e.g., `memories/plans/`, `memories/knowledge/`).
3.  **Invoke the Extractor:** In a new chat, you reference the extractor prompt and the target conversation log you want to process.
4.  **Agent Executes:** The AI agent reads the conversation, identifies relevant content, and uses tools like `write_note` and `search_notes` to persist the information into the correct folders. It also attempts to update existing notes to avoid duplication.
5.  **Build the Knowledge Base:** Repeat this process for any significant conversation to continuously build your project's memory.
6.  **Query the Knowledge:** In future sessions, you can ask the agent questions that leverage this accumulated knowledge, allowing it to provide summaries of past issues, recall previous solutions, and make more informed decisions.

### Key Benefits

-   **Persistent Memory:** Create a lasting, structured record of your project's evolution.
-   **Avoid Repeating Mistakes:** Easily reference "lessons learned" to guide future development.
-   **Improved Context:** Bootstrap new AI tasks with a rich foundation of historical knowledge and decisions.
-   **Efficient Knowledge Retrieval:** Quickly query your project's memory instead of manually searching through old chat logs.

## Spoken Prompts

~~~markdown
Please use basic memory to summarize some of the issues I've had with TypeScript, and I think there were some server errors in there or something.
~~~

## Key Prompts and Invocations

The core of this workflow is the "extractor" prompt, which defines the task for the AI agent.

~~~markdown
# Extract Conversation into memories/ using Basic Memory MCP

## Goal
Extract important information from a referenced conversation into the following folders using the available tools:

### Folders
- `plans` - action plans, roadmaps, to-do lists
- `knowledge` - stable reference facts, policies, domain docs
- `decisions` - architecture / product choices & rationale
- `lessons_learned` - retrospectives, what-went-well, mistakes to avoid

### Tasks
1.  **Scan the `conversation_log`** for the following:
    -   `#Plans` - any clearly stated tasks, next steps, or roadmaps
    -   `#Knowledge` - stable facts, policies, formulas, specs
    -   `#Decisions` - explicit choices made and their justification
    -   `#Lessons Learned` - mistakes, insights, or heuristics expressed

2.  **For each extracted item:**
    -   Choose a clear, concise `title`.
    -   Run `write_note` with the `folder` set to the target directory.

3.  **Link and relate:**
    -   Use wiki links (`[[Other Note]]`) to connect to existing notes when relevant.

4.  **Verify and report:**
    -   After all writes/edits, call `sync_status()` to confirm memory health.
    -   Provide a summary list of the notes you created or updated.
~~~

To run the extraction process, you reference the extractor prompt and the target conversation in the chat input. Using XML tags helps the agent clearly identify the conversation file.

~~~markdown
@extract-conversation.md

<conversation>
@script-generator-2025-05-29-09-37-troubleshooting-server-errors-and-api-issues.md
</conversation>
~~~

A folder full of Markdown notes often feels disconnected. Links between files are just plain text, making it impossible to navigate your thoughts or see how ideas relate to one another. This lesson demonstrates a powerful solution: the "Foam" extension for VS Code and its forks, like Cursor.

Foam instantly supercharges your Markdown workflow by adding features inspired by Zettelkasten and Roam Research. It turns your simple folder of files into a cohesive, navigable knowledge base.

**This lesson shows you how to:**

*   Install and use the Foam extension to enable clickable wikilinks and hover previews.
*   Visualize your entire knowledge base with an interactive graph view to discover connections.
*   Combine Foam's organizational power with Cursor's AI by opening your knowledge base in a dedicated workspace.
*   Use AI agents to perform high-level tasks like refactoring, consolidating, and cleaning up your entire collection of notes.

By the end, you'll have a streamlined system for not only capturing and connecting knowledge but also for using AI to manage and maintain it effortlessly.

### Prompts
~~~markdown
The next thing I want to work on is sharing scripts between users.
~~~
~~~markdown
Please scan through my lessons learned directory. Look through all the files in there. If there's any duplicates, please consolidate and compact them into smaller files and just do a general cleanup pass through our entire lessons learned directory.
~~~

### Commands
~~~bash
cursor memories
~~~

vscode

AI agents are only as smart as the information they can access. Manually curating and feeding them knowledge is a slow, tedious process. This lesson demonstrates a powerful, automated approach using a command-line interface (CLI) tool to programmatically generate structured notes, making them instantly available to AI agents like Cursor's Composer.

This method allows you to script the creation of your knowledge base, import notes from other sources, or even pipe the output of other AI models directly into your "second brain." The end result is a robust, up-to-date knowledge system that empowers your AI agents to provide more accurate and context-aware assistance.

### Simple Note Creation

At its core, the workflow uses a CLI tool to create a markdown file with the correct frontmatter and content. You can specify the title, folder, and content directly from the command line.

This is perfect for simple scripting or quick note creation without leaving the terminal.

~~~bash
bm --project "script-generator" tool write-note --title "Hello World" --folder "knowledge" --content "Hi John"
~~~

This command generates a `Hello World.md` file inside the `knowledge` folder:

~~~markdown
---
title: Hello World
type: note
permalink: knowledge/hello-world
---

Hi John
~~~

### Automating with AI-Generated Content

The real power comes from chaining tools together. You can use one tool (like an AI model) to generate content and pipe its output directly into the note-creation tool. This creates a fully automated pipeline for populating your knowledge base.

Here, we ask Claude to generate a list of TypeScript best practices and pipe the result directly into our `bm` tool to create a new note.

~~~bash
claude -p "Generate a list of TypeScript best practices" | bm --project "script-generator" tool write-note --title "TypeScript Best Practices" --folder "knowledge"
~~~

### The Payoff: Instant AI Recall

Once these notes are part of your project's knowledge base, your AI agent can find and use them based on simple, natural language queries. You don't need to remember the exact file name or location; the agent's semantic search capabilities handle the retrieval.

When asked to find specific information, the agent can recall the document you just created.

~~~markdown
Please load in our TypeScript best practices for imports.
~~~

By automating the creation of your knowledge base, you build a powerful, scalable system that enhances the capabilities of your AI tools, making them more effective for both personal productivity and team collaboration.

Developer ideation is often chaotic. Thoughts, bugs, and feature ideas strike at random times, and jotting them down in a daily scratchpad is easy. The hard part is turning that unstructured brain-dump into organized, actionable tasks. This process is manual, tedious, and ripe for automation.

This lesson demonstrates how to build a powerful, end-to-end pipeline in Cursor that bridges the gap between ideation and execution. By combining the quick-capture convenience of the Foam extension for daily notes with a custom, reusable AI rule, you can create a seamless workflow that automatically parses your thoughts, categorizes them, and generates structured issue files in your project.

You will learn to:

*   **Configure a Daily Scratchpad:** Use Foam and a simple setting to create a dedicated, easily accessible place for your daily notes.
*   **Structure Your Issues:** Set up a dedicated "issues" project with conventional commit-style folders (`fix/`, `feature/`, etc.) to keep tasks organized.
*   **Automate with a Reusable Rule:** Build and refine a powerful Cursor rule that instructs an AI agent to read your daily note, extract actionable items, and create new, properly formatted issue files in the correct folders.
*   **Iterate for Reliability:** See the importance of making rules explicit by including specific MCP tool calls to ensure the AI performs the automation reliably every time.

This workflow transforms a messy but necessary habit—jotting down daily notes—into the first, automated step of your development lifecycle, saving you time and ensuring no good idea gets lost.

## Step 1: Configure Your Daily Scratchpad

By default, the Foam VS Code extension creates daily notes in your project root, which can be messy. A simple configuration in your workspace `settings.json` directs these notes into a dedicated folder.

```json
// .vscode/settings.json
{
  "foam.openDailyNote.directory": "notes"
}
```

With this and a keyboard shortcut, you have an instant-access scratchpad to capture thoughts without cluttering your project.

## Step 2: Create a Memory Project for Issues

Before automating, we need a destination. We can instruct the AI to set up a structured "memory project" to house our organized tasks.

~~~markdown
Create a new memory project called issues in the root of my directory with a few. Folders that are named after conventional commit messages like fix and feature and chore and refactor and perf.
~~~

This creates a clear, conventional structure for our automated workflow to target.

## Step 3: Extract and Organize Notes into Issues

This is the core of the automation. We prompt the agent to read the daily note, identify distinct tasks, and file them correctly in our `issues` project.

~~~markdown
Please extract the content from my daily note and organize it into files inside the proper folders in my issues project. Please make sure to switch to the issues project first.
~~~

## Step 4: Capture and Refine the Workflow as a Reusable Rule

To make this process repeatable, we capture it in a Cursor Rule. The initial rule might be too general, leading the AI to perform actions manually instead of using more robust, structured tools (MCPs).

We iterate and refine the rule by making it more explicit, including the exact MCP tool names for each step. This ensures the AI follows the exact, reliable procedure every time.

**Refining the rule with a more specific prompt:**

~~~markdown
Please also include all the exact MCP tools that need to be used in each of the steps.
~~~

The final rule becomes a reliable, one-command solution to process your daily notes.

## The Final Workflow

Once the refined rule is in place, the daily workflow is simple:

1.  Jot down thoughts, bugs, and feature ideas in your daily note throughout the day.
2.  At any time, start a new agent conversation.
3.  Reference the rule (e.g., `@create-issues-from-today`).

The agent will execute the precise, multi-step process, turning your raw notes into perfectly structured and filed issues, complete with front matter and permalinks, ready for you to start working.

When working with AI agents in Cursor, you might notice that the context from one task can bleed into another. A "memory project" set in one chat will remain active even when you start a new conversation. This persistence, managed by an underlying MCP (Model Context Protocol) server, is powerful but can lead to confusion and errors—like writing notes or files to the wrong project—if you're not aware of it.

This lesson dives into how this persistence works, shows you how to inspect the underlying configuration and logs, and demonstrates the most critical best practice for working with multiple memory projects: always start your task by explicitly telling the AI which project to use. By adopting this simple habit, you can prevent context-switching errors and ensure your AI agents work reliably and predictably across all your projects.

### The Problem
The state of the active "memory project" is cached and persists across different chat sessions. If you switch from working on "Project A" to "Project B" without explicitly changing the memory project, the AI might still operate within the context of "Project A," causing it to save files or access information from the wrong place.

### The Solution
To ensure the AI always operates in the correct context, make it a habit to start any multi-step prompt, rule, or script with a clear, explicit command to switch to the desired memory project. This simple first step prevents ambiguity and ensures your actions are always applied to the correct target.

### How it's demonstrated in this lesson:
- Switching and verifying the current memory project using chat commands.
- Observing how the project state persists in a new chat session.
- Inspecting the `mcp.json` configuration to see how the default project is set.
- Viewing the `MCP Logs` in the Output panel to understand the server's lifecycle.
- A practical example of creating a file in the wrong project due to a persistent context.
- The correct workflow: prepending a "switch project" command to ensure the file is created in the right place.

### Prompts

~~~markdown
Please get my current memory project.
~~~

~~~markdown
Set my current memory project to issues.
~~~

~~~markdown
Set my current memory project to script-generator.
~~~

~~~markdown
Switch my current project to issues.
~~~

~~~markdown
Please show me my current memory project.
~~~

~~~markdown
Create a markdown note in my knowledge folder that there is a grid view and a list view, and that grid view appears in desktop mode, and list view appears on mobile mode.
~~~

~~~markdown
Please switch to my script generator memory project.
~~~

### Commands

~~~bash
/mcp
~~~

### Code Snippets

This `mcp.json` configuration shows the `basic-memory` server being started with a default `--project` of `script-generator`.

~~~json
{
  "mcpServers": {
    "basic-memory": {
      "command": "uvx",
      "args": [
        "basic-memory",
        "mcp",
        "--project",
        "script-generator",
        "mcp"
      ]
    }
  }
}
~~~

Manually running AI agents or multi-step processes in your editor is tedious and repetitive, even with powerful tools. Interactive prompts slow you down when you know exactly what task you want done. This lesson demonstrates how to transform a multi-step, interactive AI workflow into a single, executable bash script.

You'll learn how to leverage Cursor's "rules," MCP (Model Context Protocol) tools, and the command line to create fully automated, locked-down scripts. Go from manually guiding an AI through parsing daily notes and creating structured issue files to running a single, reliable command that does it all for you.

### Workflow Demonstrated

*   Configure an MCP server to provide custom tools to the AI (e.g., for a note-taking system).
*   Create a "Cursor Rule" (a detailed prompt file) that defines the multi-step task.
*   Run the rule interactively, approving each tool the AI wants to use.
*   Convert the interactive process into a non-interactive script using command-line flags (`-p` for print mode, `--allowedTools` for security).
*   Use the AI to generate a final, reusable bash script from the complex command.

### Key Benefits

*   **Full Automation:** Turn complex, multi-step AI interactions into a single, reusable command.
*   **Increased Speed:** Eliminate the need for interactive approvals and manual steps.
*   **Security & Reliability:** Lock down scripts by explicitly allowing only the necessary tools, preventing unexpected actions.
*   **Reusability:** Encapsulate powerful workflows into simple scripts that you or your team can run.

### Prompts

~~~markdown
Please create a bash script in my scripts folder for this command cat .cursor/rules/create-issues-from-today.mdc | claude -p --allowedTools "mcp_basic-memory_switch_project,mcp_basic-memory_write_note"
~~~

### Terminal Commands

~~~bash
# Add a new MCP server named 'basic-memory' that uses the 'bm' command
claude mcp add -t stdio basic-memory -- bm --project "issues" mcp
~~~

~~~bash
# Launch the Claude interactive agent
claude
~~~

~~~bash
# Inside Claude, view the configured MCP servers
/mcp
~~~

~~~bash
# Run a rule file interactively
cat .cursor/rules/create-issues-from-today.mdc | claude
~~~

~~~bash
# Run the same rule file non-interactively, pre-approving specific tools
cat .cursor/rules/create-issues-from-today.mdc | claude -p --allowedTools "mcp_basic-memory_switch_project,mcp_basic-memory_write_note"
~~~

~~~bash
# Run the final, generated script
./scripts/create-issues-from-today.sh
~~~

~~~bash
# Verify the output of the script
cat issues/feature/Add\ chat\ feature\ for\ script\ collaboration.md
~~~

### Code Snippets

~~~json
// .claude/settings.local.json
{
  "permissions": [
    {
      "allow": [
        "mcp_basic-memory_switch_project",
        "mcp_basic-memory_write_note"
      ],
      "deny": []
    }
  ]
}
~~~

Creating a simple AI agent in Cursor is straightforward, but making it perform a complex, multi-step task reliably requires more than just a basic prompt. Agents often fail due to missing permissions, a lack of real-world context (like the current date), or an incorrect understanding of the required sequence of actions.

This lesson demonstrates the practical, iterative process of building and refining a sophisticated custom agent from the ground up. You will learn how to meticulously configure the agent's tool permissions, craft detailed step-by-step instructions to guide its behavior, and troubleshoot common failure points.

The result is a powerful, one-click automation that can process a daily note, extract actionable items, and create new issues in a separate project context. This hands-on example showcases how to build robust, personalized AI workflows that go far beyond simple chat commands.

### The Process of Refining an Agent

This lesson walks through the real-world process of programming an AI agent, which involves:

*   **Initial Setup:** Creating a new custom agent, assigning it a name ("Create Issues"), and setting a convenient keybinding (Cmd/Ctrl + M).
*   **Permission Scoping:** Starting with a minimal set of tool permissions (e.g., only "Run Commands" and a specific "MCP Server") to ensure security and predictable behavior.
*   **Detailed Prompting:** Providing a comprehensive, multi-step set of custom instructions that act as the agent's core logic or "rule."
*   **Testing and Observation:** Running the agent and carefully observing its output and failure points.
*   **Iterative Refinement:**
    *   Adding necessary permissions (like `read_file` and `search_files`) only when the agent reports it cannot perform a required action.
    *   Enhancing the custom instructions to be more explicit, such as telling the agent *how* to get the current date with a specific terminal command.
    *   Adjusting the order of operations in the instructions to ensure a logical workflow (e.g., reading a local file *before* switching to a different project context).
*   **Finalization:** Continuing to test and refine until the agent performs the entire desired workflow flawlessly and efficiently with a single command.

### Prompts

A prompt to start the demonstration:
~~~markdown
Let's make the hero text larger and move it down a little bit.
~~~

The simple trigger word used to activate the fully programmed agent:
~~~markdown
go
~~~

A prompt to give the agent date-awareness:
~~~markdown
run a terminal command to determine today's date
~~~

Another prompt to help the agent find the correct file:
~~~markdown
find the note matching today's date in the following format.
~~~

### Commands

The terminal command the agent is instructed to use to find the current date:
~~~bash
date +%Y-%m-%d
~~~

### Code Snippets

The final, refined custom instructions pasted into the agent's configuration. This multi-step prompt guides the agent through the entire workflow, including error handling and context switching.
~~~markdown
# Rule: create-issues-from-today

## Description
This rule describes the process for extracting content from a daily note and creating categorized issues (features, fixes, etc.) in a separate memory project.

## Steps (with MCP Tools)
0. Read the content of ./notes/YYYY-MM-DD.md using the read_file tool.
1. **Switch to the 'issues' memory project**
   - Tool: `mcp_basic-memory_switch_project`
   - Usage: Switch to the `issues` project to access its file structure and create new notes.
2. **Extract Actionable Items from Note**
   - Process the content of the daily note provided.
   - For each actionable item (e.g., a bug, a feature request), create a new note in the appropriate folder (`fix/`, `feature/`, etc.) within the `issues` memory project.
   - Tool: `mcp_basic-memory_write_note` (to add references/links in the note content)
   - Usage: If needed, add references back to the original daily note for traceability.
3. **Switch back to the "script-generator" project**
   - Tool: `mcp_basic-memory_switch_project`
   - Usage: Switch back to the "script-generator" project to continue working on the script.

## Example
- A bug described in the daily note becomes a file in `fix/`.
- A performance concern becomes a file in `perf/`.

This process ensures daily notes are systematically converted into actionable, categorized issues for tracking and follow-up.
~~~

Create an AI-Automated MCP-Driven Markdown Knowledge Base

[00:00] Once you install basic memory, either with UV or brew, you'll see that it installs a basic memory executable, aliased as BM. So if I type BM help, you'll see some of the options that we have here. Right now we're mostly interested in the project and the MCP. So I'm going to say bmprojectadd, and I'm going to call this script generator after the name of my current project. And then I'm going to add this to my dev script generator directory, then slash memories.

[00:34] Now this is going to set up a directory in my current project called memories and this directory is currently empty and basic memory will write markdown files to this directory. Now to set up this specific basic memory project for our project, we'll go down into the project command, which you can find in here under multiple projects. We'll copy this and in our cursor directory we're going to create a new file, call this mcp.json, and then just paste the contents of that JSON. It'll say new MCP server detected, click enable, and now if you check in your settings, Command-Shift-J, and go down to the tools and integrations, you'll see that basic memory would be enabled here. Because I copy and pasted I need to adjust this to script generator.

[01:22] Hit save and then we should be back in business. So now we have our tools enabled. You'll see it has the ability to read and write notes and search the notes and everything. So if we do our basic agent command we'll just say please use basic memory to write a hello world note. Hit enter.

[01:39] You'll see it calls write note and the result is created notes and so you'll see In our memories directory we will now have a memories notes hello world. And so now if I start a new conversation and I ask it to using basic memory please read all of the notes I've created so far and summarize them for me we'll get back this extremely basic here's your hello world note where it called this directory and got back the notes directory. It read that specific note and got its content back. And now we have a straightforward way of managing markdown files over MCP Using our agent.



https://app.egghead.io/api/v1/lessons/foundation-building-ai-memory-with-mcp-and-cursor~duu9m/transcript

[00:00] One of the best things to capture as memories are your past conversations, and you can open your agent and navigate your conversations from here in the show chat history, find the one you want. Let's grab this one, and then we could select the dots again and say export chat. This could export our chat to our downloads folder. We'll open it here and we have a markdown file, which we could then simply just drag and drop into our memories. I'm actually going to create a folder called conversations, then drag this file into here.

[00:32] Now you'll probably want to give it a title and a type and a note. So we'll copy and paste these up here and drop in this front matter and then cursor tab does its magic and suggests the perfect everything for that. So I just hit tab and selected everything there and I can go and start a new conversation and say please use basic memory to find my conversation about the prompt builder and summarize it. We may want to rethink how we approach this. Then you'll see basic memory will reach out to search your notes, it'll read the note, and if you look at what it searched, it searched for prompt builder and it found an array of results, and then once it found the note that it needed you can see it found its identifier and then it read in our file.

[01:17] So now we have a nice summary of a conversation we had in the past. Now if for some reason this fell out of sync, if you run the bm –help command you will see that there is a sync command. Because the memories are based on Markdown files but it still uses a SQLite database for the searching and querying, you could just run bmsync to make sure everything is up to date if you're manually editing files.



https://app.egghead.io/api/v1/lessons/capture-transforming-cursor-ai-conversations-into-persistent-knowledge~bfk4f/transcript

[00:00] I really don't like the flow of exporting conversations from Cursor, so I built a tool called Cursor History, which you can install using npm. So we'll just install this globally, and once that's installed it includes a command called chi for Cursor History. And when you pass in --"select", it will look through all the conversations in this workspace that it's currently in and allow you to go back and search through any of the conversations. So if I search for like perf it'll look for ones for performance wins or build anything with build in the title or content of the conversation. And then if I just navigate down and select one, let's just do this one, it'll output the path and from the terminal I can just either command click on this and cursor will open up the exported conversation, which I can then browse through see if I want to keep it.

[00:46] And if I want to keep it I can just go into my memories and my conversations and then just drag this tab in here. We're going to allow this to remove the line terminators, that's fine. And now we have this conversation which is also organized by the workspace name. So script generator is the workspace name and that has a nice time stamp on it as well. When you export these and if you have a lot of conversations that you export they'll be sorted by workspace name and by time stamp rather than the way that cursor exports a conversation with just the name of the conversation.

[01:14] So then I can use the agent and ask my basic memory to find this document and summarize it. So for example, please use basic memory to find where I was troubleshooting server errors and summarize what it found. Then just let this run. And this document isn't in context right now, So it's going to have to use the basic memory MCP to find it. So it's going to search my notes, and then it read the note that it found, and it brings it in and can summarize what this conversation was about.

[01:42] With the CHI tool there are a lot more commands you can use. If you do --"help", you can see that the default command will just export the latest conversation. So if we try this now, so chi, it should attempt to export this conversation we just ran. So if we look at this document and look at the content, you'll see here's what I just queried, and here's the summary. Now I will say that there have been some issues with running the CHI tool before Cursor has had a chance to save the conversation to the database.

[02:12] So sometimes this may fail. Make sure and check out the result. And there's no real way to force cursor to save this conversation to the database, so just always double check the output.



https://app.egghead.io/api/v1/lessons/streamline-automating-cursor-history-export-with-cli-tools~k73na/transcript

[00:00] Now that we have our long conversation saved, let's use a prompt to extract information from the conversation into various folders in our memory. So this prompt defines the folders to use, lists out all of the MCP tools available through basic memory, and tells it to take that conversation and essentially break it down into these various notes. So if I reference extract conversation, and then I like to add a XML tag like this, conversation, and then add the conversation I'm targeting, and then close the tag, just to help the agent know where the conversation starts and ends, and we'll send it, sit back, let the agent call the MCP and read through the conversation and start reading and generating notes. And this will search through existing notes as well to attempt to update them if we already have information on this. So you'll see it read the main conversation, it's searching notes for existing related data, and it's writing out some relevant notes around knowledge, plans, more plans, and lessons learned.

[01:02] So if we check in on some of these, and you'll see a summary of what it did below, which you can read through and validate. But if we check in our lessons learned, you'll see some specific information around releases, and how it's handling JSON files, and our knowledge. You'll see it's discussing some of the errors that were caught. And then in our plans, this is an older plan from this project, so these are all things I've already handled, but these are definitely plans that I would have looked into based on that conversation. And now we can continue to build up our knowledge base.

[01:35] So if we just extract another conversation with select, let's go back in time a little bit. We'll check on this cleanup TypeScript errors and bring this conversation in, drop that in there, then start a new conversation where we reference our extractor. We toss in our conversation, then we'll just toss in our markdown, close this off, let this run, and it will go ahead and pull information out of that conversation as well. So this one added TypeScript errors to our knowledge and lessons learned for TypeScript. So essentially now, based on those two conversations, if we start a new conversation, we can ask questions like, please use basic memory to summarize some of the issues I've had with TypeScript and I think there were some server errors in there or something.

[02:20] Now if you just remember like the general concept of something that went wrong in the past that you want to avoid when you're working with the agent now, you can start by bringing in this as an initial query or initial prompt, so that when you tell your agent to start working on these things, it will avoid them as it's going through these steps.



https://app.egghead.io/api/v1/lessons/extract-mining-ai-insights-from-chat-logs-with-mcp-powered-analysis~jnw3u/transcript

[00:00] Now you'll notice in a lot of the memories that you've captured there's links to other files, but there's really no way for you to navigate to them. You can fix that by installing an extension called Foam, which allows you to manage markdown knowledge bases inside of VS Code and its various forks. So now with this installed, if I just reopen this file, I can now command click on this and jump over to it and hover over each of these and jump around. And if you want to leverage all of Foam's features, if you just open cursor, we'll clear this out, open cursor to the memories directory. Now if we run a command like foam new note, and we'll just title this next steps, then I can take a note the next thing I want to work on is sharing scripts between users.

[00:47] Or we can have foam show graph to see how everything links together. Like clear out everything here you can see we can zoom in on nodes and how things are connected. So if you want to be completely knowledge focused you can navigate this way, jump around, clean things up. And then if you open your agent, because we're now isolated to the memories directory, you can say things like please scan through my lessons learned directory, look through all the files in there, if there's any duplicates please consolidate and compact them into smaller files, and just do a general cleanup pass through our entire lessons learned directory, and then just let this go to work on cleaning up some of the memories, see what it recommends, and use built-in agents to help manage your knowledge as it grows.



https://app.egghead.io/api/v1/lessons/connect-building-interconnected-knowledge-graphs-with-foam-and-cursor~7flsi/transcript

[00:00] If you're a fan of automation, which I assume most of you are, and want to build tools around this, you can use BM for basic memory. I'm going to target my project as script generator. Then I can invoke any of the tools. I'm going to invoke the write note tool with a title of Hello World, a folder of knowledge, and content of Hi John. Then this will instantly create a Hello World file inside of my knowledge with the content of Hi John.

[00:31] So this is amazing for importing notes or generating notes. For example, Claude with a prompt of generate a list of typescript best practices and piping that to BM into my script generator project with a tool of write note and then the title TypeScript best practices and a folder of knowledge. Then we just hit enter and then however many seconds later we now have a knowledge TypeScript best practices document which was created by Cloud Code and we can store this in our memory and tweak it for personal use or for our team. So the next time I invoke an agent and I start a new conversation, I don't even need to know about that document. I can say, please load in our TypeScript best practices for imports, and it will go ahead and call our MCP tool.

[01:24] And it found, I'll scroll back up, you'll see it found the note for our best practices right in the document, so that we pulled in this sort of information only using plain English inside of the agent.



https://app.egghead.io/api/v1/lessons/automate-scripting-ai-knowledge-creation-with-mcp-cli-tools~cp2rr/transcript

[00:00] Foam has a keyboard shortcut for creating a note for today, but if you run it, it's going to create this file in the root of your project. So let's delete that and start over by opening our workspace settings, the JSON version, go down to the bottom of the file and we'll say foam open daily note and set this to a notes directory. Now once we run that today note shortcut which was option D it'll pop open this file and we can jot down whatever thoughts we just had working on our project. I noticed a bug where a user created duplicate scripts with the same title and I'd also like to address the performance in the pagination to get to the last page faster. So we'll jot those down, then anytime or in any other file if we want to jot down a note, it's just option D.

[00:47] It pops you right back to that file no matter what. Even if it's closed, option D. You can just jot down notes. Now what you can do with this is go into your agent, we'll start a fresh conversation, and tell it to create a new memory project called issues in the root of my directory with a few folders that are named after conventional commit messages like fix and feature and chore and refactor and perf. Then this can use the mcp to ping off of basic memory and if we check out the result from the MCP, you'll see create memory project.

[01:19] It created a project named issues inside of our current project here. I would say that if you're going to support multiple projects with basic memory, you probably want to have something like script-generator-issues as a project name. Then once it added this project we now have all these folders which we can check on in here and then I can tell it to please extract the content from my daily note and organize it into files inside the proper folders in my issues project. Please make sure to switch to the issues project first. Then we'll let this run and you can see it switched over to our issues project.

[01:54] So now our notes are extracted into issues. We have a fix here, we have a perf here, and we've essentially started this pipeline of a quick ideation of the things that we need to work on. Then we can take these issues, push them up to GitHub, start working on them, and once we learn from the work we can store that back into our memories. It's definitely worth taking the time in a workflow like this where you want your agent to accomplish a specific task with specific folders to create a rule for this. So I'm going to generate a new rule, I'm going to call it create issues from today.

[02:30] Then I'm going to drag this rule in here and say, please update this rule with the steps required to take today's note and organize it as we did in this conversation. So let's check out our result, switch the issues project, find the daily note, extract actionable items. I'm going to go ahead and list the available folders here. So I'll tell it with command-I, bring that part over, please create a bulleted list of all the available folders so it's more explicit. So I'll go ahead and accept this change where I added the folders up here.

[03:04] And so now in the future, once we start a new agent conversation, if we just hop over to our scratchpad with option D, I'll go ahead and get rid of this. I'll come up with some scenario like I want to add a chat feature so that users can message each other about their scripts. And there's this bug if you click on the submit button five times too quickly a pop-up window alert shows up. Kind of a non-set scenario. I'm going to open the agent.

[03:28] I'm going to bring in our focused Recent rule with reset context. I'll reference our rule for create issues. We'll go ahead and hit enter here and let it do its work. Unfortunately, it looks like our rule was not clear enough because it created these files manually instead of using the MCP. So even though these got to the right place, it didn't add things like the front matter which the MCP API would have created.

[03:54] So we're going to reject all of these. We're going to update our rule to be a bit more specific. So I'm going to navigate back to our previous conversation and tell it to please also include all the exact MCP tools that need to be used in each of the steps. And now looking through this you can see the exact tools it's referencing. So we'll accept this and let's ditch this extra front matter, some weird formatting there.

[04:18] We'll swap back to our previous conversation that failed, scroll back up, we can rerun this, and this time it should call the mcp-tools. Now we have in our issues directory, we have feature, here's our chat feature request, now it has the proper front matter and permalinks. We have a fix request about submit button presses, and now these are queued up to move the project forward.



https://app.egghead.io/api/v1/lessons/ideate-from-daily-notes-to-actionable-issues-with-cursor~s9j1t/transcript

[00:00] Now it is important to be aware of switching back and forth between projects. So if I say please get my current memory project, so right now it's set to script generator, and I say set my current memory project to issues, like we did when parsing out the notes from today, this will now be set to issues. Now if I start a new conversation and I say please get my current memory project, you'll see this is still set to issues. Now if you look at the settings with Command-Shift-J, hop over to the tools, you can hit tab to focus the search box and search quickly. We'll scroll down to basic memory and you'll see it's essentially starting up an MCP server when cursor starts up.

[00:38] And if you ever want to look at the output of MCP servers and see what's going on, if you focus on the output view with command-shift-U, make sure and swap over to the MCP logs. You can also search for it in the command palette, it's called output view. I'll go ahead and clear the output, you'll see if I toggle basic memory off and on again, you'll see it's handling the listings and it's connected and it found the tools and that's about as much information as you get. So in this scenario when you run this again, you'll see that the current memory project is still set to issues. Now because this is cached somewhere, when swapping back and forth between various tasks, if you want to be very specific about which memory project to use, you should always start with in your rules or scripts which one you want it to use to avoid accidentally calling another one.

[01:24] So just set my current memory project to script generator is enough to make sure your agent starts with the right files and directories when working with multiple projects. So it's just important to keep in mind in case you start building up lots of projects that step number one in rules and in scripts is always switch project. Because you'll notice that even if I say switch my current project to issues and I'll open up Cloud code, which I'll show you how to configure in the next lesson. If I run the slash mcp command, you'll see basic memory was already set up. And if I tell Claude to check on please show me my current memory project, You'll see the current project is issues.

[02:03] So there's something at the basic memory level which is storing the current project and nothing short of quitting cursor so that everything shuts down. We'll reset this back to default. It's just one of those situations where you don't know if that's a bug or a feature, But it's definitely something to be aware of. So if I say something like create a markdown note in my knowledge folder that there is a grid view and a list view and that grid view appears in desktop mode and list view appears on mobile mode, we'll see that it's writing a note and it created a note in a knowledge folder, but if we check our issues directory you'll see a new knowledge folder. That's obviously not what we wanted, so I'd have to delete that, come back up, insert, please switch to my script generator memory project, then run this again, and now this time we'll have our knowledge with our new note in place in the correct folder and in the correct project.



https://app.egghead.io/api/v1/lessons/context-mastering-project-switching-in-cursors-ai-memory-system~fiyzv/transcript

[00:00] So I removed all the issues that we generated from the agent using our cursor rule, and this time I'm going to do it in a scripted fashion by invoking clod and saying mcp add basic memory. Now this uses a transport of standard I O and the arguments to launch basic memory are VM which is a Global I have installed for basic memory with a project of issues and it launches in MCP mode So running this command will allow me to launch Claude and I'll hit slash MCP and you'll see basic memory listed. I'll dig in, you can see the tools and how we launched it. And if you look at the tools, you'll see the tools we used in our agent before. And specifically if we look at something like write note, you'll see the full name of the tool which will be very important to us.

[00:48] Now what we can do is just exit out of everything, clear our terminal, and we can pipe our cursor rules create issues from today and pipe that into Clod. Now this will launch Clod in interactive mode And it'll pull in that cursor rule, essentially use it as a workflow or script to work through, and it'll ask us to allow it to use these commands like basic memory switch project. I'll hit 2 to approve that. And actually while this is working I'm going to come over to our rule. And if you remember from our previous lesson if we're going to script this I definitely want to have the last step be this switch back to script generator as our main project.

[01:30] So the last thing it does is to switch back. Then we'll need to approve every MCP tool it attempts to use. So now it'll say what it did, get the final message, and if we look in our issues directory you'll see a feature and a fix based on our notes from today. I'm going to delete these again and this time instead of running CLOD in an interactive mode we're actually going to run CLOD in what's called a print mode where all it's going to do is run in the background and once it's done print out what happened and exit. Then also for complete control of this, we're going to list the allowed tools.

[02:07] And the only tools we're going to allow are these specific MCP tools required to achieve this task. And if you look at the tools that it created in the clod settings local. You'll see it listed the ones we need for us here. So all we're going to do is allow clod code to switch projects and write notes. It won't be able to manually edit files or delete anything.

[02:28] We'll completely lock it down to these two abilities. So I'm going to grab these out. I need to quickly remove the quotes just so I can copy and paste this, and then I'll undo, undo, undo. Then to run our command again, this time we will cat and run our previous command, but this time we'll do it with the P flag for print mode and we'll pass in the allowed tools. And I don't know why that's camel cased and every other flag is dash cased, but I'll pass in the two tools we'll allow it to use.

[02:58] Then you can just sit back and relax while it parses your notes from today and automatically creates those issues in the issues memory project. So once it's done all you'll get back is that final message, which will probably be very similar to the previous final message. And if we look in our issues folder inside a feature We can look at the file I created and we've scripted that entire thing away. So then obviously the next step would be to grab this command from our history. We'll go ahead and echo this out and say please create a bash script in my scripts folder for this command.

[03:35] Make sure to escape the quotes here, here, and pipe this into Cloud. Hit enter and then let Cloud create that script for us. Make it executable. And now that we have that script, I'll go ahead and remove my issues from the feature. I'll remove that.

[03:51] I'll remove my issues from the fix. Remove that. Then just run my script of create issues from today. Then I can go grab a sandwich. Then check on the two issues it created, under issues, feature, and you can see we've completely scripted away the process.



https://app.egghead.io/api/v1/lessons/script-creating-reusable-ai-automation-with-mcp-and-claude-code~wkko9/transcript

[00:00] Now instead of a script you can also just create a custom agent. So if I drop in something like, let's make the hero text larger and move it down a little bit. Then I'll open the agent panel and create a custom agent down in this menu with add custom mode. We'll call this create issues. The name doesn't really matter.

[00:16] We'll set a key by clicking this and I'll use command M. Then I'll click again. I know command M is minimized but I never use that anyway. Then I'm going to disable search, disable edit, and only allow it to run commands and mcp servers. Let's disable all of them and only pick basic memory.

[00:34] And then in the advanced options we can turn off all of this. And I'm going to swap over to my cursor rule and copy the entire body of this rule into the custom instructions. If you try and reference the rule from in here, it doesn't always work, so I prefer just to copy and paste the entire thing in. So now from anywhere, if I close this, close all my files, hit command M, I can just say go. You need to type at least something.

[01:02] Hit enter and then it'll run through the instructions you gave it. Oh, I did need to enable autorun. So let's modify this. Advanced options, autorun. Then let's start this again.

[01:13] Hit enter and now it'll walk through all the tool calling. And it looks like because we didn't specifically reference the markdown file, let's update the instructions here where we edit the advanced options. And my biggest gripe about this whole UI is how difficult it is to update everything. So we'll call this create issues from today. And let's start with run a terminal command to determine today's date, then find the note matching today's date in the following format.

[01:41] And we'll say notes, and this will be year, year, year, year, month, month, day, day, mark down, then give it one more shot. It is worth noting that anytime you're using agents they are not aware of the date. It's not part of their data and they'll often think it's a year before or something. So let's give this another shot. So now it generates the date and now we need to tweak it again so that it can actually read files.

[02:05] So we'll allow it to read files but do nothing else. And this is just kind of the process when figuring out how restrictive you want an agent to be. And I'm also going to grab this command, which it ran, and bring this in to here. Since it worked once, we're going to learn from that and say, use this bash command. This way it should consistently use the same command every time.

[02:30] And now we'll run it one more time and this time it should be able to read the file. It should consistently generate the date for us. So now it's reading the content. So we still didn't give it enough permissions to actually locate files. So one last edit here under search.

[02:45] Let's give it search files as well and then fire this off and now we got the date and this time it was able to Read in the daily note, but it looks like it attempted to find it through the MCP first So we'll give this one last little tweak. I believe in our steps. Let's say step zero is read the content of Notes, and you'll have to excuse me the scrolling jumps around in this UI quite a bit. And I haven't found any text files backing this up. So notes, year year year, month month, day day, and we'll even say using the read file tool, which is Cursor's internal tool for reading files.

[03:26] And now if we run this again it should avoid making a bunch of calls before switching, which appear to be trying to read the file. And let's delete the file it made last time. So last time it created this. Run this one more time. So now we have the date.

[03:40] Now it read the file. Switching project. Write note. And you can see we have a much better step-by-step, much less tool calling, much faster, and everything ended up in the right spot. So it's under here, under a feature folder, and we're done.



https://app.egghead.io/api/v1/lessons/agent-build-a-custom-agent-mode-in-cursor-for-managing-notes~bd52n/transcript

Create an AI-Automated MCP-Driven Markdown Knowledge Base

John Lindquist

Course Content