Author: Tuan Nguyen

Exploring Microsoft Agent Framework: Building and Orchestrating the Future of AI Agents

Posted on by Tuan Nguyen

As Artificial Intelligence (AI) continues to evolve, agents—intelligent entities that can reason, act, and collaborate—are becoming the backbone of the next wave of AI systems. In this post, we explore Microsoft Agent Framework (MAF) — an open-source SDK that helps developers build, connect, and orchestrate intelligent agents and multi-agent workflows efficiently.

1) What Is an AI Agent, and Why Do We Need a Framework?

An AI agent is more than a chatbot. It is capable of understanding input (text or voice), reasoning with a large language model (LLM), calling external tools or APIs, and producing contextual output.

  • Understand user input
  • Reason and decide using an LLM
  • Act by invoking tools/APIs
  • Deliver contextual outputs and next steps

Building these systems from scratch is complex: you must manage state, tool integrations, safety, and coordination across multiple agents. Microsoft Agent Framework standardizes these components so teams can prototype, scale, and govern agentic systems more effectively.

Microsoft Learn overview

2) Overview of Microsoft Agent Framework (MAF)

2.1 What It Is

Microsoft Agent Framework is an open-source SDK to build agentic applications with .NET or Python. It unifies Microsoft’s earlier frameworks—Semantic Kernel and AutoGen—into a single, enterprise-friendly platform.

GitHub repository

2.2 Core Capabilities

  • Single-Agent Development: Build standalone agents that process inputs, reason with LLMs, call tools, and produce responses.
  • Multi-Agent Workflows: Connect agents to collaborate on complex tasks with orchestration, routing, nesting, checkpointing, and human-in-the-loop.
  • Extensibility & Observability: Integrate APIs/tools easily, monitor behavior, and apply governance controls.
  • Cross-Platform: Works with Python and .NET; supports popular model providers such as OpenAI and Azure OpenAI.

Explore capabilities on Microsoft Learn

2.3 Why It Matters

MAF blends rapid prototyping with production-grade features—ideal for developers and enterprises accelerating AI integration while maintaining control and safety.

3) Architecture and How It Works

3.1 Key Components

  • LLM Integration: Use models (e.g., GPT-4 via Azure OpenAI/OpenAI) for reasoning and NLU.
  • Context & Memory: Thread/context management lets agents maintain state and recall history.
  • Middleware: Insert safety checks, logging, or custom logic in the interaction pipeline.
  • Tool Integration: Invoke external APIs/tools (including via protocols such as MCP).
  • Workflow Engine: Orchestrate multi-agent systems with routing, nesting, and checkpointing.

3.2 Quick Start (Python)

pip install agent-framework --pre

For .NET, install the appropriate NuGet package and create a similar setup. See the quick start guides for step-by-step instructions.

Quick Start on Microsoft Learn

4) Real-World Use Cases

  • Customer Support: Triage, escalate, collaborate with human agents, and retain conversation history.
  • Finance & Operations: Document analysis, reporting pipelines, and workflow approvals.
  • Enterprise Automation: Multi-agent orchestration for supply chain, HR, or data processing.
  • Knowledge Management: Agents that query enterprise data and deliver contextual answers.

Azure AI Foundry: Agent Service overview

5) Benefits and Challenges

Benefits

  • Rapid development: High-level abstractions speed up agent creation and orchestration.
  • Flexible & modular: Suitable for single-agent apps and complex multi-agent workflows.
  • Enterprise-ready: Logging, observability, governance, and robust integrations.
  • Open source: Transparent and customizable via GitHub.

Challenges

  • Learning curve: Requires familiarity with LLMs, state, and workflow orchestration.
  • Complexity: Might be overkill for very small projects.
  • Data privacy & safety: External tool calls and memory require careful design.
  • API evolution: Public-preview features may change as the framework matures.

6) How to Get Started

  • Set up your environment: Install Python 3.10+ or .NET 8.0+ and configure OpenAI/Azure OpenAI credentials.
  • Install the framework:
pip install agent-framework --pre
  • Define your first agent: Choose a model, write clear instructions, and add one or more tools (APIs/functions).

  • Test and debug.

7) Conclusion

Microsoft Agent Framework is a significant step toward fully agentic AI systems, bridging the gap between simple LLM apps and orchestrated, multi-agent ecosystems. Start small, experiment, and scale once you validate your approach.

References

Unlock the Power of Your Unstructured Data with Dify’s Knowledge Pipeline

Posted on by Tuan Nguyen

In today’s data-driven world, the ability to transform messy, unstructured enterprise data into valuable, actionable insights is a game-changer. But let’s face it, the process is often a headache. Critical information is scattered across PDFs, PowerPoints, spreadsheets, and various other formats, making it a challenge to create a unified, reliable source of context for Large Language Models (LLMs).

This is where Dify’s Knowledge Pipeline comes in, offering a visual, adaptable, and scalable solution to streamline your data processing workflow.

What is the Knowledge Pipeline?

The Knowledge Pipeline is a feature within the Dify platform that allows you to create a visual workflow for processing your data. Think of it as a canvas where you can drag, drop, and connect different “nodes,” each representing a specific step in the data processing journey. This visual approach takes the guesswork out of the traditional “black box” method of data processing, giving you full control and observability over the entire process.

The primary goal of the Knowledge Pipeline is to convert your unstructured enterprise data into high-quality context that can be used by LLMs. This is a crucial step in building powerful and accurate Retrieval-Augmented Generation (RAG) applications.

Key Features That Make a Difference

The Knowledge Pipeline is packed with features designed to simplify and enhance your data processing efforts:

  • Visual and Orchestrated Workflow: The intuitive canvas experience allows you to visually design your data processing pipeline, making it easy to understand and manage the entire workflow.

  • Enterprise-Grade Data Source Integrations: Connect to a wide range of data sources, including local files, cloud storage (like Google Drive and AWS S3), and online documentation platforms (like Notion and Confluence).

  • Pluggable Data Processing Pipeline: The pipeline is divided into distinct stages—Extract, Transform, and Load—allowing you to customize each step with different plugins to suit your specific needs.

  • Multiple Chunking Strategies: Choose from various chunking strategies, including “General Mode” for large batches of documents, “Parent-Child Mode” for long, technical documents, and “Q&A Mode” for extracting structured question-answer pairs.

  • Image Extraction and Retrieval: The pipeline can extract and process images from your documents, enabling you to build multimodal search and retrieval applications.

  • Observable Debugging: Test and debug your pipeline step-by-step, inspecting the inputs and outputs at each node to quickly identify and resolve any issues.

  • Built-in Templates: Get started quickly with a variety of pre-built templates for common use cases, such as processing long documents, extracting data from tables, and enriching content with LLMs.

Sample Usage

Here is a step-by-step guide on how to use the Knowledge Pipeline to process a .docx document file and ingest it into a knowledge base.

Step 1: Start from a Template

Instead of creating a blank pipeline, we’ll start with a pre-designed template to streamline the work.

  1. From the main Knowledge screen, select “Create from Knowledge Pipeline”.

  2. A list of templates will appear. Choose the “Convert to Markdown” template. This template is ideal for processing Office files like DOCX by converting them to Markdown format before chunking, which helps improve the quality of information processing.

Step 2: Review the Pre-built Pipeline

After selecting the template, you’ll be taken to a canvas with a pre-configured pipeline. This pipeline consists of several connected nodes:

  • FILE: The data source node where you will upload your file.

  • MARKDOWN: This node converts the content from the DOCX file into Markdown format.

  • PARENT-CHILD CHUNKER: This node splits the text using the “Parent-Child” chunking strategy, which helps retain the context of larger sections while ensuring precision when retrieving smaller chunks.

  • KNOWLEDGE BASE: The final node where the processed data is stored.

Step 3: Test Run and Fine-tune the Pipeline

Before publishing, you should run a test to ensure everything works as expected.

  1. Click the “Test Run” button in the top-right corner.

  2. In the “Test Run” window, under the DATA SOURCE step, upload your document (e.g., dify_guide_vi.docx).

  3. Click “Next” to proceed to the DOCUMENT PROCESSING step. Here, you can adjust the chunking parameters, such as the maximum length for parent and child chunks.

  4. Click “Process” and view the output in the RESULT tab. You will see how your document has been divided into smaller chunks.

Step 4: Publish the Pipeline

Once you are satisfied with the test run results, it’s time to publish the pipeline for official use.

  1. Click the blue “Publish” button in the top-right corner.

  2. A confirmation dialog will appear, noting that the knowledge base’s structure cannot be modified after publishing. Click “Confirm” to finish.

Step 5: Add Documents and Use the Knowledge Base

Now your pipeline is live and ready to process files.

  1. In your knowledge base, navigate to the “Documents” tab.

  2. Click “Add file” and upload the dify_guide_vi.docx file (or any other document).

  3. The pipeline will automatically process the file. Once completed, you will see your file listed with an “Available” status.

Your knowledge base is now ready to be linked to your AI applications, providing accurate context directly from your documents.

References:

https://dify.ai/blog/introducing-knowledge-pipeline
https://docs.dify.ai/en/guides/knowledge-base/knowledge-pipeline/readme

Claude Code Plugins

Posted on by Tuan Nguyen

Introduction

Claude Code now supports plugins — modular extensions that let you customize and extend Claude Code’s capabilities by bundling slash commands, agents (subagents), Model Context Protocol (MCP) servers, and hooks.

Plugins provide a lightweight, shareable way to package workflows, integrations, and automation, so you and your team can standardize and reuse custom logic.

Features

Here are the main features and capabilities of Claude Code plugins:

  • Slash Commands: You can define custom commands (e.g. /hello, /format) to trigger specific behaviors or shortcuts.
  • Subagents / Agents: Plugins may include purpose-built agents for specialized tasks.
  • MCP Servers Integration: You can bundle MCP server definitions to connect Claude Code to external tools, services, or data sources.
  • Hooks / Event Handlers: Plugins can define hooks to run custom logic at key points in the workflow (e.g. on specific events).
  • Toggleable / Modular: You can enable or disable plugins to adjust Claude Code’s context footprint and reduce complexity when not needed.
  • Plugin Marketplaces: Plugins can be bundled into marketplaces (catalogs), making it easier for teams or the community to share and reuse plugin collections.
  • Team / Repository-level Plugins: You can declare in your project’s configuration which marketplaces and plugins should be used, so team members get consistent plugin setups.

Installation / Setup

Here’s a high-level guide on how to install and set up plugins in Claude Code:

Prerequisites

  • Claude Code must already be installed and running.
  • You should have basic command-line familiarity.

Basic Steps & Quickstart

Create a plugin (for developers):

  • Make a directory for the plugin, e.g. my-first-plugin, and inside it a .claude-plugin/plugin.json manifest that describes the plugin (name, version, author, description).
  • Optionally, add subdirectories for commands/, agents/, hooks/, etc., containing your plugin logic.
  • If you want to distribute, create a marketplace.json that references your plugin(s).

Install / enable plugins (as a user):

  • Inside Claude Code, use the /plugin command.
  • You may first add a marketplace, e.g.: 
    /plugin marketplace add user-or-org/repo-name

    Then browse or install from that marketplace.

  • Or use direct install commands, for example: 
    /plugin install my-plugin@marketplace-name

    You can also enable, disable, or uninstall as needed.

  • After installing a plugin, you may need to restart Claude Code to activate the new plugin.

Verify the installation:

  • Use /help to check if new slash commands or features appear.
  • Use /plugin → “Manage Plugins” to inspect installed plugins and see what they provide.

Team / Repository Plugin Setup:

In a project repo’s .claude/settings.json, you can declare which marketplaces and plugins should be used by all team members.
When users “trust” the repo, Claude Code will auto-install those plugins.

Developing & testing locally:

  • Use a local “development marketplace” structure to test plugins in isolation.
  • Iterate: uninstall and reinstall the plugin after modifications to test changes.
  • Debug by checking directory structure, stepping through individual components, and using provided CLI debugging tools.

Demo (Example Walkthrough)

Here’s a simple example to illustrate how one might build, install, and test a minimal plugin for Claude Code.

Example: Greeting Plugin

Create plugin skeleton

test-marketplace/
  .claude-plugin/
    marketplace.json
  my-first-plugin/
    .claude-plugin/
      plugin.json
    commands/
      hello.md

plugin.json (inside my-first-plugin/.claude-plugin/):

{
  "name": "my-first-plugin",
  "description": "A simple greeting plugin to learn the basics",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  }
}

commands/hello.md:

---
description: Greet the user with a personalized message
---

# Hello Command  
Greet the user warmly and ask how you can help them today. Make the greeting personal and encouraging.

marketplace.json (in test-marketplace/.claude-plugin/):

{
  "name": "test-marketplace",
  "owner": {
    "name": "Test User"
  },
  "plugins": [
    {
      "name": "my-first-plugin",
      "source": "./my-first-plugin",
      "description": "My first test plugin"
    }
  ]
}

Launch Claude Code & install plugin

cd test-marketplace
claude

Within Claude Code:

/plugin marketplace add ./test-marketplace
/plugin install my-first-plugin@test-marketplace

Select “Install now” when prompted, and then restart Claude Code if needed.

Test the plugin

  • Run /hello → you should see Claude respond using your greeting command.
  • Run /help → the hello command should appear in the list.


References:
https://www.anthropic.com/news/claude-code-plugins
https://docs.claude.com/en/docs/claude-code/setup

Quick Guide to Using Jules

Posted on by Tuan Nguyen

Jules is Google’s asynchronous AI coding agent that integrates directly with your GitHub repositories to perform tasks like fixing bugs, writing tests, building new features, and bumping dependency versions.

Getting Started:

  1. Connect GitHub: Visit jules.google, select your repository and branch

  2. Assign Tasks: Write a detailed prompt for Jules, or add the “jules” label to a GitHub issue

  3. Jules Works: Jules fetches your repository, clones it to a Cloud VM, and develops a plan using the latest Gemini 2.5 Pro model Jules – An Asynchronous Coding Agent

  4. Review & Approve: Jules provides a diff of the changes for you to browse and approve
  5. Create PR: Once approved, Jules creates a pull request for you to merge and publish on GitHub

Benefits of Using MD vs XLSX for Knowledge Base on Dify

Posted on by Tuan Nguyen

Why Use Markdown?

1. Better AI Processing

  • Semantic understanding: AI models process continuous text more effectively than fragmented cell data
  • Context preservation: Paragraph-based content maintains relationships between information
  • Effective retrieval: Vector embeddings capture meaning better from natural language text
  • Natural chunking: Content splits logically by sections, preserving context in each chunk

2. Cost Efficiency

  • Smaller storage: Plain text (5-10KB) vs Excel with formatting overhead (50-100KB+)
  • Lower token usage: Markdown structure is simpler, reducing embedding and processing tokens
  • Faster processing: Text parsing is significantly faster than Excel binary format

3. Operational Benefits

  • Version control friendly: Git tracks line-by-line changes effectively
  • Universal editing: Any text editor works, no proprietary software needed
  • Better collaboration: Merge conflicts are easier to resolve in plain text
  • Automation ready: Easily integrated into CI/CD and documentation workflows

4. When to Use Excel?

XLSX may be suitable when:

  • You need structured tabular data with calculations/formulas
  • Data is primarily numerical with specific formatting requirements
  • Direct import/export with database systems or business intelligence tools
  • Non-technical users need to edit data in familiar spreadsheet interface

However, for knowledge bases consumed by AI, converting to Markdown yields better results even for tabular data.

Demo: Converting XLSX to MD

You can create a custom plugin tool on Dify to convert Excel files to Markdown. Here’s how I built mine:

Implementation Steps

  1. Accept XLSX file input
    • Require Xlsx File parameter and wrap its blob in a BytesIO stream
  2. Configure column selection
    • Extract Selected Columns parameter (accepts list/JSON string/comma-separated string)
    • Ensure it is non-empty
  3. Set delimiter
    • Resolve Delimiter parameter for separating entries
  4. Parse Excel file
    • Read the first worksheet into a DataFrame using pandas
    • Verify all requested columns exist in the DataFrame header
    • Subset DataFrame to selected columns only
    • Normalize NaN values to None
  5. Transform to structured data
    • Convert each row into a dictionary keyed by selected column names
    • If no rows remain, emit message indicating no data and stop
  6. Generate Markdown
    • Build content by writing column: value lines per row
    • Append delimiter between entries
    • Join all blocks into final Markdown
  7. Output file
    • Derive filename from uploaded file metadata
    • Emit blob message with Markdown bytes and metadata

Sample

Input

 

Output

Spec Kit: A Smarter Way to Build Software with AI

Posted on by Tuan Nguyen

Have you ever asked someone to help you with a project, only to get back something that looks right but isn’t quite what you wanted? That’s exactly what happens when we work with AI coding assistants today. We describe what we want, get code back, and often find ourselves saying “Well, it’s close, but…”

GitHub just released a free tool called Spec Kit that solves this problem by teaching us a better way to communicate with AI assistants. Think of it as a structured conversation method that helps both you and the AI stay on the same page.

The Problem: Why “Just Tell the AI What You Want” Doesn’t Work

Imagine you’re renovating your kitchen and you tell the contractor: “I want it to look modern and functional.” Without more details, they’ll make their best guess based on what they think “modern” and “functional” mean. The result might be beautiful, but probably won’t match your vision.

The same thing happens with AI coding assistants. When we give vague instructions like “build me a photo sharing app,” the AI has to guess at hundreds of details:

  • How should users organize their photos?
  • Can they share albums with friends?
  • Should it work on phones and computers?
  • How do they sign in?

Some guesses will be right, some won’t, and you often won’t discover the problems until much later in the process.

The Solution: Spec-Driven Development

Spec-Driven Development is like having a detailed conversation before starting any work. Instead of jumping straight into building, you:

  1. Clearly describe what you want (the “what” and “why”)
  2. Plan how to build it (the technical approach)
  3. Break it into small steps (manageable tasks)
  4. Build it step by step (focused implementation)

The magic happens because each step builds on the previous one, creating a clear roadmap that both you and the AI can follow.

How Spec Kit Makes This Easy

Spec Kit provides a simple toolkit with four phases that anyone can learn:

Phase 1: Specify – “What do you want to build?”

You describe your vision in plain language, focusing on:

  • Who will use it? (your target users)
  • What problem does it solve? (the main purpose)
  • How will people use it? (the user experience)
  • What does success look like? (your goals)

Example: Instead of “build a task manager,” you’d say:

“Build a team productivity app where project managers can assign tasks to engineers, team members can move tasks between ‘To Do,’ ‘In Progress,’ and ‘Done’ columns, and everyone can leave comments on tasks. It should be easy to see at a glance which tasks are yours versus others.”

Phase 2: Plan – “How should we build it?”

Now you get technical (but still in everyday terms):

  • What technology should we use? (website, mobile app, etc.)
  • What are the constraints? (budget, timeline, compatibility needs)
  • What are the rules? (security requirements, company standards)

Example:

“Build this as a simple web application that works in any browser. Store data locally on the user’s computer – no cloud storage needed. Keep it simple with minimal external dependencies.”

Phase 3: Tasks – “What are the specific steps?”

The AI breaks your big vision into small, manageable pieces:

  • Create user login system
  • Build the task board layout
  • Add drag-and-drop functionality
  • Implement commenting system

Each task is something that can be built and tested independently.

Phase 4: Implement – “Let’s build it!”

Your AI assistant tackles each task one by one, and you review focused changes instead of overwhelming code dumps.

Why This Approach Works Better

Traditional approach: “Build me a photo sharing app” → AI makes 1000 assumptions → You get something that’s 70% right

Spec-driven approach: Clear specification → Detailed plan → Small tasks → AI builds exactly what you described

The key insight is that AI assistants are incredibly good at following detailed instructions, but terrible at reading your mind. By being explicit upfront, you get much better results.

Getting Started with Spec Kit

Spec Kit works with popular AI coding assistants like:

  • GitHub Copilot
  • Claude Code
  • Gemini CLI

Installing and Using Spec Kit

1. Install Specify

uv tool install specify-cli –from git+https://github.com/github/spec-kit.git
specify init reading-assistant

2. Establish project principles

/constitution Create principles focused on code quality, testing standards, user experience consistency, and performance requirements

3. Create the spec

/specify
GOAL
– Input: URL (or pasted text)
– Process: Fetch article → summarize (150–250 words) → generate 3–5 practice questions
– Output: Markdown with Summary, Questions, Source
– Constraint: Minimal Python CLI

4. Create a technical implementation plan

/plan
ARCHITECTURE
– Python CLI with argparse
– Modules:
• fetcher.py: download HTML
• extractor.py: parse text with BeautifulSoup
• llm.py: call OpenAI (gpt-4o-mini)
• markdown.py: render Markdown
– Flow: URL/text → fetch & extract → LLM → Markdown → stdout

DEPENDENCIES
– requests, beautifulsoup4, python-dotenv

OUTPUT FORMAT
# Summary
<summary>

# Questions
1. …
2. …

# Source
<url or ‘pasted text’>

5. Break down into tasks

/tasks
– [ ] Setup project skeleton + requirements
– [ ] Implement fetcher (requests)
– [ ] Implement extractor (BeautifulSoup)
– [ ] Implement LLM client with prompt
– [ ] Implement Markdown renderer
– [ ] Wire CLI (argparse)
– [ ] Smoke test with one URL and one pasted file
– [ ] Add README with quick start

6. Execute implementation

/implement
FILES
1) requirements.txt
requests
beautifulsoup4
python-dotenv

2) app.py
– argparse: –url, –text
– orchestrate modules and print Markdown

3) fetcher.py
– fetch_url(url) with timeout, retry

4) extractor.py
– extract_text(html) → title + paragraphs

5) llm.py
– summarize_and_ask(text) → {“summary”: str, “questions”: [str]}
– uses OPENAI_API_KEY; friendly error if missing

6) markdown.py
– render(result, source) → Markdown string

7) README.md
– Quick start instructions
– Example commands

 

Result

 

References:

https://github.com/github/spec-kit

https://github.blog/ai-and-ml/generative-ai/spec-driven-development-with-ai-get-started-with-a-new-open-source-toolkit/

Genspark AI Docs – Intelligent Document Creation Tool

Posted on by Tuan Nguyen

Introduction

Genspark AI Docs is the world’s first fully-agentic AI-powered document creation tool, designed to automatically generate comprehensive documents. It leverages advanced AI agents to conduct research, write content, and format documents seamlessly.

Key Features

  • Full-agentic AI approach: automates the entire document creation process, including research, content generation, formatting.
  • Visual integration: integrates visual elements, and provides intelligent design.
  • Multi-format support: supports both Rich Text and Markdown formats.

How It Works

  • Users simply enter a prompt describing the document they need.
  • AI analyzes the request and creates a complete document.
  • Documents adapt to user needs, incorporate uploaded or external content and support real-time iterative refinement.

Practical Applications

  • Technical Specs and API Documentation.
  • Meeting Minutes → Action Plan Transformer.
  • Sales Proposals and Pricing Sheets.
  • Internal SOPs and Onboarding Playbooks.
  • Project Proposals and Progress Reports.

Quick Start Guide

  1. Visit https://www.genspark.ai
  2. Sign up or log in to your account
  3. Select AI Docs from the dashboard
  4. Enter your desired prompt

  5. Wait for the content to be generated
  6. Click on any element to format it if needed
  7. Export the document as HTML, Word, or PDF when you’re ready

AIPM: Project Management with AI-Powered Automation

Posted on by Tuan Nguyen

Introduction

AIPM (AI‑powered Project Management) v0 is an innovative framework designed by Miyatti that uses PMBOK, Lean UX, and Agile methodologies—streamlines the project lifecycle through AI assistance and structured documentation workflows.

Core Components

  1. Three-tier document structure:
    Flow: a draft workspace with date‑organized notes.
    Stock: approved, formal deliverables stored by phase.
    Archive: immutable records of completed projects.
  2. Workflow engine: LLM-assisted “Ask → Draft → Review → Sync” process, managed by a robust rules engine built on .mdc files.
  3.  Hybrid methodology:
    PMBOK for structure (“What”).
    Lean UX for discovery (“Why”).
    Agile for execution (“How”).

Strengths

  • Efficient documentation: Only drafts that pass review move to Stock, reducing clutter and focusing on essential deliverables.
  • Methodological rigor: Combines PMBOK’s structure, Lean UX’s problem framing, and Agile’s adaptability in a unified workflow.
  • LLM-powered automation: Accelerates document creation with tailored prompts and templates, reducing repetitive admin tasks.
  • Customizable rules: Built around easy-to-edit .mdc files (e.g., 00_master_rules, flow_to_stock_rules), making it extensible and flexible.
  • Seamless dev integration: Includes support for development workflows (e.g., environment setup, story planning), ensuring tech tasks are synced with PM processes.

Weaknesses

  • Steep learning curve: Requires familiarity with .mdc syntax and rule logic to fully harness system capabilities.
  • Tool & language lock-in: Depends on the Cursor editor and Japanese trigger phrases.
  • Version Control Complexity: Managing collaborative work across the Flow/Stock/Archived structure may become complex in larger teams without proper version control strategies.

How to use

A. System Requirements

  • Cursor editor for LLM prompts.
  • Git for cloning the repo.
  • Bash or compatible shell.

B. Quick Setup (via Cursor)

  • Open Cursor and select New Window.
  • Enter the repository URL: https://github.com/miyatti777/aipm_v0.
  • In the Chat panel, type: “Please perform initial setup / 初期設定お願いします” — Cursor will automate folder structure and rule setup.

C. Manual Setup

  • Clone the Repository.
    git clone https://github.com/miyatti777/aipm_v0.git
    cd aipm_v0
  • Run Setup Script.
    ./setup_workspace_simple.sh setup_config.sh
  • Verify the directory structure.

D. Configuration Options

  • Edit setup_config.sh (AUTO_APPROVE, AUTO_CLONE, RULE_REPOS, PROGRAM_REPOS) to customize behaviors, templates.
  • Set user rules from the Cursor settings (you can change the original rules from Japanese to English).
    #========================================================
    # 0. Base Policy
    #========================================================
    ! Always respond in English
    – Check if any rules are attached. If so, be sure to load them. Mark with ✅ once loaded.
    – Deliverables should be created as files using `edit_file` where possible (split into smaller parts).
    – Tasks such as MCP or file viewing should be executed autonomously if possible.
    – When receiving a task request, identify missing information, plan by yourself, and proceed to the goal.#========================================================
    # 0. Safe Execution of Shell Commands
    #========================================================
    ! Important: Prohibited and recommended practices when executing commands
    – Absolutely do not use subshell functions (`$(command)` format).
    – Backticks (“command“) are also prohibited.
    – Complex commands using pipes (`|`) or redirects (`>`) must be broken into simple, individual commands.
    – When date information is needed:
    1. First, run a standalone `date` command and get the terminal output.
    2. Use the resulting date string explicitly in the next command.
    3. Example: Run `date +%Y-%m-%d` → output `2024-05-12` → use this string directly.! Command Execution Example
    – Not Allowed: `mkdir -p Flow/$(date +%Y%m)/$(date +%Y-%m-%d)`
    – Allowed: [Break into the following two steps]
    1. `date +%Y%m`
    2. `date +%Y-%m-%d`
    3. `mkdir -p Flow/{output1}/{output2}`#========================================================
    # 1. Mandatory Rule File References (pre-load)
    #========================================================
    # * Prioritize loading `pmbok_paths_*.mdc` first. All subsequent paths
    # should be referenced using {{dirs.*}} / {{patterns.*}} variables.required_rule_files:
    – /Users/<YOUR_USER>/{{PROJECT_ROOT}}/.cursor/rules/basic/pmbok_paths.mdc
    – /Users/<YOUR_USER>/{{PROJECT_ROOT}}/.cursor/rules/basic/00_master_rules.mdc

E. Usage

Project Initialization

  • Start by typing: “I want to make curry. Please start a project.” (Japanese: カレー作りたい プロジェクト開始して).

  • After that, you can continue with commands like:
    “I want to create a project charter.”
    “Define the product.”
    “I want to do stakeholder analysis.”
  •  For each step, the AI will ask for your confirmation. If everything looks good, you can reply with “Confirm and reflect” to proceed.

You can continue with other phases, as shown in this example: [Usage by phase]

 

References

https://github.com/miyatti777/aipm_v0

https://deepwiki.com/miyatti777/aipm_v0

Sync Your Kindle Highlights to Obsidian

Posted on by Tuan Nguyen

If you use Obsidian for note-taking and read books on Kindle, the Obsidian Kindle Highlights plugin is a game-changer. This plugin lets you import your Kindle highlights directly into your Obsidian vault.

Key Features

  • Sync highlights from your Kindle (via My Clippings.txt or Amazon account).

  • Customize note format with templates.

  • Make highlights searchable and linkable in Obsidian.

 

How to Use

  1. Install and enable the plugin from Obsidian’s community plugins.
  2. Upload your My Clippings.txt.
  3. Click ‘Sync Now’ to sync your highlights using the default format.
  4. Feel free to adjust the templates later to fit your needs.
  5. Take a look at my sample template below.
    File name{{author}}-{{title}}

    File content

    —
    tags: kindle
    status: currently reading
    —

    # {{longTitle}}
    ## Metadata
    {% trim %}
    {% if authorUrl %}
    * Author: [{{author}}]({{authorUrl}})
    {% elif author %}
    * Author: [[{{author}}]]
    {% endif %}
    {% endtrim %}

    ## Highlights
    {{highlights}}

    Highlight

    – Highlight: {{text}}

    – Page: {{page}}

    {% if note %}
    – Note: {{note}}
    {% endif %}
    —

 

 

Summary: The Obsidian Kindle Highlights plugin makes it easy to import and organize your Kindle highlights in Obsidian, helping you build a useful, searchable knowledge base from your reading.

 

 

Dify MCP Plugin & Zapier: A Hands-On Guide to Agent Tool Integration

Posted on by Tuan Nguyen

Introduction

Leverage the power of the Model Context Protocol (MCP) in Dify to connect your agents with Zapier’s extensive application library and automate complex workflows. Before we dive into the integration steps, let’s quickly clarify the key players involved:

  • Dify: This is an LLMops platform designed to help you easily build, deploy, and manage AI-powered applications and agents. It supports various large language models and provides tools for creating complex AI workflows.
  • Zapier: Think of Zapier as a universal translator and automation engine for web applications. It connects thousands of different apps (like Gmail, Slack, Google Sheets, etc.) allowing you to create automated workflows between them without needing to write code.
  • MCP (Model Context Protocol): This is essentially a standardized ‘language’ or set of rules. It allows AI agents, like those built in Dify, to understand what external tools (like specific Zapier actions) do and how to use them correctly.

Now that we understand the components, let’s explore how to bring these powerful tools together.

Integrating Zapier with Dify via MCP

Zapier Setup

  1. Visit Zapier MCP Settings.
  2. Copy your unique MCP Server Endpoint link.
  3. Click “Edit MCP Actions” to add new tools and actions.
  4. Click “Add a new action”.
  5. Select and configure specific actions like “Gmail: Reply to Email”.
  6. To set up:
    – Click “Connect to a new Gmail account”, log in, and authorize your account.

    – For fields like thread, to, and body, select “Have AI guess a value for this field”.
  7. Repeat to expand your toolkit with “Gmail: Send Email” action.

MCP Plugins on Dify

  • MCP SSE: A plugin that communicates with one or more MCP Servers using HTTP + Server-Sent Events (SSE), enabling your Agent to discover and invoke external tools dynamically.
  • MCP Agent Strategy: This plugin integrates MCP directly into Workflow Agent nodes, empowering agents to autonomously decide and call external tools based on MCP-defined logic.

MCP SSE

Customize the JSON template below by inputting your Zapier MCP Server URL in place of the existing one. Paste the resulting complete JSON configuration into the installed plugin.

{
“server_name”: {
“url”: “https://actions.zapier.com/mcp/*******/sse”,
“headers”: {},
“timeout”: 5,
“sse_read_timeout”: 300
}
}

 

 

After setting things up, proceed to create a new Agent app. Ensure you enable your configured MCP SSE plugin under ‘Tools’. This allows the Agent to automatically trigger relevant tools based on the user’s intent, such as drafting and sending emails via an integrated Gmail action.

MCP Agent Strategy

Besides the SSE plugin, the MCP Agent Strategy plugin puts MCP right into your workflow’s Agent nodes. After installing it, set up the MCP Server URL just like before. This allows your workflow agents to automatically use Zapier MCP on their own to do tasks like sending Gmail emails within your automated workflows.

Final Notes

Currently (April 2025), Dify’s MCP capabilities are thanks to fantastic community plugins – our sincere thanks to the contributors! We’re also developing built-in MCP support to make setting up services like Zapier MCP and Composio within Dify even easier. This will unlock more powerful integrations for everyone. More updates are coming soon!

References: Dify MCP Plugin Hands-On Guide: Integrating Zapier for Effortless Agent Tool Calls

 

 

 

 

 

© 2015 - 2025 Scuti. All rights reserved.