AI Concepts on Yanmu

What Are Agent and Harness? — Video Notes

Mon, 25 May 2026 02:00:00 +0800

One-Sentence Summary

An Agent solves how AI gets work done; a Harness solves how AI does work reliably. Together, they form the foundation of products like Claude Code, Codex, Open Cloud, and Qwen.

1. From ChatGPT to AI Agent

The Original Problem

Asking ChatGPT to create an animation with HTML + SVG (e.g., an Apple logo drawn with lines) often produces poor results — even in 2026, AI struggles with even a minimalist logo.

Manual Improvement

Search for Apple SVG assets on sites like iconfont
Feed the SVG code to AI and ask it to recreate it
Results improve significantly, but manually finding assets every time is tedious

Automated Improvement — Wrapper Sites (Earliest Agent Prototype)

Build a website that wraps ChatGPT via API calls, adding backend functions:

User submits request → The site tells AI: “Here’s the user’s prompt. I also have a logo search function you can call when needed.”
AI analyzes → Determines it needs an Apple logo, responds: “Call the asset search tool with parameter: Apple logo”
Site executes → Backend runs the search function and finds SVG assets
Final generation → The site sends assets + user prompt to AI to complete the animation

2. Two Core Working Modes of Agent

1. ReAct (Reasoning + Acting) — Step by Step

Three-step loop:

Think: AI analyzes the request, determines what’s needed and which tool to call
Act: AI tells the backend to call a tool (e.g., search for assets)
Observe: Backend returns results; AI sees them and continues

The loop repeats: Think → Act → Observe, until the task is complete.

This is the most fundamental working pattern of almost all AI Agents, including Claude Code, Codex, and Open Cloud.

2. Plan & Execute — Plan First, Then Execute

Plan first: Generate a work list / step sequence upon receiving the task
Execute: Follow the checklist step by step

Mode	Analogy	Characteristic
ReAct	Improvise as you go	Flexible, adjust on the fly
Plan & Execute	Research before traveling	Structured, suited for complex tasks

Real agents combine both. For example, Qwen’s “Task Assistant” mode: first analyzes requirements and creates steps (Plan), then proactively searches, writes code, and adjusts (Act).

3. Advanced Agent Capabilities

Tool Calling / Function Calling

The Agent determines which tools to call based on the user prompt; the backend executes them and returns results.

Context Management and Compression

Large models have no memory — each conversation starts fresh
The Agent must send the entire conversation history to the AI each time, which grows longer over time
Context window = AI’s workspace, limited in size
Context compression: When the conversation exceeds the window, earlier content is summarized into a condensed version
- Trade-off: compression loses information, potentially causing the AI to forget previous instructions

Multi-Agent Collaboration

One AI acts as the project manager (understanding requirements, breaking down tasks, assigning work), while other AIs execute subtasks.

Each sub-AI has its own independent context window
The project manager only sees final results, not intermediate steps
Improves efficiency while mitigating context explosion

4. Harness — The Safety Net for Reliable AI

When Agents run in production, they encounter various issues that need a Harness to solve.

Engineering Checkpoints in a Harness

Checkpoint	Problem	Solution
Format Sanitization	AI adds “okay”, markdown code blocks, or extra newlines when returning JSON	Clean: remove fluff, wrapping symbols, extra newlines; send errors back for regeneration if still failing
Parameter Validation	Tool call parameters are invalid (e.g., city field contains a non-city name)	Validate format/range before calling; reject and request refill if invalid
Input Filtering	Prompt injection attacks (“ignore all previous instructions”) / malicious SVG uploads	Scan user input for suspicious instructions and asset safety before processing
Output Filtering	AI-generated content may contain malicious code	Scan output content for threats
Hard-Coded Validation	AI repeatedly makes the same error (e.g., always using pure white backgrounds)	Enforce with code: auto-detect SVG background color and replace white with dark

Core Principle of Harness Engineering

If you can enforce it with code, never rely on prompting alone.

5. Complete Architecture Summary

One Sentence to Elevate

Agent is the horse; Harness is the tack. A horse without tack runs into problems; tack without a horse does nothing. Together, they transform AI from a chat-only chatbot into a worker that gets things done in the real world.

Context7 Guide: Help Your AI Coding Assistant Read the Latest Docs

Sat, 02 May 2026 19:51:00 +0800

Overview

Ever had this experience: you ask AI to write some code, it churns out a bunch, then you run it and get errors. Or you call an API that’s clearly documented, but the AI says it “doesn’t exist.”

It’s not that the AI is dumb — it’s that its training data has an expiration date. The data might be months or even years old, and frameworks have been updated several times since.

Context7 solves exactly this. Built by the Upstash team, it fetches the latest official docs when you ask a question, injects them into the AI’s context, and lets the AI answer based on the current version.

Usage is simple: just add use context7 at the end of your prompt. It’s like telling the AI: “Don’t guess — check the latest docs first before answering.”

Why Do You Need It?

💥 One Example Is Enough

Say you want to add a “Back to Top” button to your personal website — when you scroll down, a button appears in the bottom-right corner; click it and you go back to the top.

What AI writes with outdated knowledge: First load a几十 KB third-party library, then write a bunch of code to use it. The feature works, but for a single button, the page gets slower and the code is bloated.

The truth is, it’s much simpler now: Modern browsers already have smooth scrolling and scroll listening built in — a few lines of code, no extra libraries needed.

AI doesn’t know this because it learned from教材 that’s years old.

With use context7, Context7 checks the latest docs and finds that native features are sufficient. So the AI chooses a lighter approach instead of giving you the old clunky solution.

It’s like asking a friend to fix your phone — they try to拆 it from memory, following steps from 3 years ago. The screw positions have changed. If they’d checked the latest tutorial first, they wouldn’t have broken it.

With vs Without Context7

	Without	With
Information source	Stale knowledge in AI’s brain, potentially outdated	Real-time docs fetched from official sources
API accuracy	Often wrong or uses deprecated APIs	Guaranteed to use current version APIs
Code quality	May use outdated patterns from years ago	Follows latest recommended practices
Version handling	Guesses regardless of version	Checks the version you specify

🔄 How It Works

Just a few steps:

You ask a question (add use context7 at the end)
    ↓
Context7 identifies which package you're asking about
    ↓
Fetches the latest content from GitHub and official docs
    ↓
Filters the most relevant snippets, injects them into the AI's "context"
    ↓
AI answers with the latest docs

“Context” is everything the AI can “see” in your current conversation. Injecting docs is like opening a reference book on the table — the AI reads and answers at the same time.

Where does the doc come from? GitHub repos, official doc sites, and llms.txt files (a special doc index format for AI).

After fetching results, Context7 uses an LLM to intelligently rank them and picks the most relevant snippets for you.

Two ways to use it:

Method	Description
MCP Mode (recommended)	Install once, AI coding assistant calls it automatically. MCP is like a plugin for AI — set it and forget it
CLI Manual Mode	Query docs manually in the terminal, for those who like tinkering

Core Capabilities

Smart Matching: You Say the Name, It Finds the Place

When you ask AI how to use a tool, Context7 needs to find the latest manual online. But multiple things can share the same name — it needs to know which one you mean.

Common names it can identify on its own. For ambiguous or common names, use the owner/repo format to be precise:

`1`	`Use /tailwindlabs/tailwindcss to add a navbar to my page. use context7`

Here tailwindlabs is the author name, tailwindcss is the project name. Like searching for “Apple” — it could be fruit or a phone. Be specific and you won’t go wrong.

Supported Libraries

All popular ones are included: React, Next.js, Vue, Tailwind CSS, Express, Prisma, Supabase, TypeScript… Full list at context7.com/rankings.

Version Awareness

Different versions can have vastly different APIs. Just specify the version and Context7 will fetch docs for that version:

1
2
3

Write a counter with Vue 3. use context7
Write an API route using Next.js 14's Pages Router. use context7
Configure dark mode with Tailwind CSS v4. use context7

If you ask for an iPhone 12 teardown guide, nobody will hand you the iPhone 15 version.

Installation

One-Click Install

`1`	`npx ctx7 setup`

npx comes with Node.js, no extra installation needed. If you haven’t installed Node.js yet, go to nodejs.org to download it — once installed, you’ll have npx.

Running it will:

Open a browser for you to log in and authorize (OAuth)
Generate an API Key (your “identity credential”)
Auto-configure your editor

Three steps and you’re done.

To specify an editor, add a parameter:

1
2
3

npx ctx7 setup --claude      # Claude Code
npx ctx7 setup --cursor      # Cursor
npx ctx7 setup --opencode    # OpenCode

Uninstall: npx ctx7 remove

Manual Configuration

If auto-install doesn’t work, manually add the MCP Server:

{
  "mcpServers": {
    "context7": {
      "url": "https://mcp.context7.com/mcp",
      "headers": {
        "CONTEXT7_API_KEY": "your API key"
      }
    }
  }
}

Configuration file locations for different tools (~ represents your user directory, e.g., C:\Users\yourusername on Windows):

Tool	Config Location
Cursor	Settings → MCP, or `~/.cursor/mcp.json`
Claude Code	`~/.claude/settings.json` (global) or `.claude/settings.json` (project)
Windsurf	Settings → Cascade → MCP servers
Cline	VS Code extension → MCP Servers → Configure
OpenCode	Project root `opencode.json`

Get your API Key at context7.com/dashboard. Format is ctx7sk..., free users get quota too.

✅ Verification

Send a test:

`1`	`Write a counter webpage with a button. use context7`

If the AI gives clean, modern code without loading extra libraries, it’s working.

Usage

Basic Usage

Add use context7 at the end of your prompt:

1
2

Write a clean personal resume page. use context7
Write a countdown tool that counts down from a given number of seconds. use context7

Specify a Library Precisely

Use the /owner/repo format to skip name matching:

`1`	`Use /tailwindlabs/tailwindcss to add a navbar to my page. use context7`

Recommended when the library name is ambiguous.

Specify a Version

1
2

Write a card layout using Bootstrap 4 instead of 5. use context7
Write a todo list using Vue 3's Composition API. use context7

Combine Multiple Libraries

`1`	`Build an icon showcase page with Bootstrap + Font Awesome. use context7`

Configure Auto-Trigger

If you don’t want to type use context7 every time, configure it in your rules file:

→ Cursor in .cursorrules:

`1`	`When user questions involve third-party framework/library API usage, automatically use Context7 to query the latest docs.`

→ Claude Code in CLAUDE.md:

1
2
3

## Documentation Query Rules
- For third-party libraries/frameworks, first use Context7 to query latest docs
- Prioritize generating code based on Context7 results

CLI Commands

If you only use Context7 in AI conversations, you can skip this. CLI is for those who like terminal commands.

npm is Node.js’s built-in package manager, -g means “global install” — install once, use everywhere.

# Install CLI
npm install -g ctx7

# Search libraries
ctx7 library react
ctx7 library nextjs "middleware"

# Get docs
ctx7 docs /facebook/react "hooks state management"
ctx7 docs /vercel/next.js "middleware authentication"

# Skills management
ctx7 skills search        # Search available Skills
ctx7 skills install       # Install Skill
ctx7 skills list          # View installed
ctx7 skills remove        # Uninstall

# Authentication
ctx7 login                # Login
ctx7 whoami               # View status
ctx7 logout               # Logout

❓ FAQ

How is this different from AI’s built-in web search?

Web search returns blog posts and forum threads of varying quality — you still have to judge credibility yourself. Context7 only pulls from official docs, uses an LLM to filter the most relevant snippets, and feeds them directly to the AI.

💰 Will `use context7` cost more?

No. Although there’s an extra doc lookup step, the AI gets accurate information so it doesn’t have to guess, rewrite, or produce long, buggy code. Overall token consumption is actually lower.

What if my library isn’t listed?

Go to context7.com and click “Add Docs” to submit it, or skip use context7 and let the AI fall back to its own knowledge.

I installed it but it doesn’t work?

Check these one by one:

Did npx ctx7 setup report any errors
Is the MCP config JSON format correct (even one extra comma will break it)
Is the API Key valid (starts with ctx7sk...)
Did you completely close and reopen your editor
Is the MCP status light green
Did you include use context7 in your prompt

Does it affect response speed?

It adds one or two seconds of wait time, but you get accurate answers without back-and-forth corrections. One debug-compile-fix cycle takes way longer than that.

Summary

Item	Content
What it is	A platform providing real-time, up-to-date documentation for AI coding assistants
Problem it solves	AI giving incorrect code due to outdated training data
Core principle	Fetch official docs in real-time, inject into AI context
Installation	`npx ctx7 setup` — one command and done
Usage	Add `use context7` at the end of your prompt
Pricing	Free tier available, sufficient for personal use
Website	context7.com
GitHub	github.com/upstash/context7

Once installed, you’ll never have to worry about AI giving you outdated knowledge again.

The Evolution of AI Programming

Fri, 20 Mar 2026 02:00:15 +0800

🤖 The Evolution of AI Programming: From Prompts and Context Engineering to Harness

As models with comparable capabilities become increasingly common, the gap in user experience between different products is actually widening. Some products write code that can be deployed directly, while others produce code that is hard to maintain—why? Because the models are the same; the difference lies in how they are used, and how to use them stably. In the AI industry, this is known as Harness Engineering.

🧠 Harness Engineering: Deconstructing the Agent into Three Layers

We divide programming Agents into three levels:

Scaffolding Responsible for all preparatory work before the AI executes a task, including the tools provisioned by the system.
Harness (Runtime Orchestration, The Core) The central dispatching hub of the entire agent. Responsible for managing the AI’s core reasoning loop, coordinating tool calls, context management, runtime security control, and persistent storage of session data.
Context Engineering Responsible for managing the resource allocation of tokens—the smallest unit of computation for large language models processing text. Determines which information should be retained and which should be discarded during the AI’s operation.

A stable and capable AI coding agent = One or more LLMs called + A robust Harness system.

⏳ Harness is Crucial, Why is it Only Getting Popular Now?

① Phase 1: Prompt Engineering

Core Focus: How to write a good instruction.

Role Setting: Defining clear identities and responsibility boundaries for the AI.
Providing Examples: Using Few-shot prompting to make the AI generate content according to a specific format and style.
Chain-of-Thought: Asking the AI in the instruction to break down the problem step-by-step and deduce logically, reducing logical leaps and errors.

② Phase 2: Context Engineering

A single prompt is no longer enough—we need to dynamically construct the entire context environment for the model. Ensuring that every time the model makes a decision, it can accurately see all the information it needs: task files, conversation history, tool rules, knowledge base entries…

Core Concept: Show the model what it needs to see, and block what it shouldn’t.

③ Phase 3: Harness Engineering

Whenever you find the Agent making a mistake, you spend time engineering a solution so it won’t make the same mistake again.

The model’s capabilities are sufficient, but it just won’t listen. What do we do? The answer is—Harness Engineering.

Real-world Cases:

Experiment	Condition	Result
LangChain	Same model, optimized Harness only	Terminal Bench 2.0: 52.8 → 66.5
Nate B Jones	Same model, same prompt, changed runtime environment only	Coding benchmark win rate: 42% → 78%
OpenAI	Started from an empty git repo, 5 months, entirely AI Agent driven	Produced ~1 million lines of code, 1500 PRs, zero human intervention

The Agent isn’t hard; the Harness is.

💥 Why Do AI Tasks Fail So Frequently?

1. Trying to do it all at once Trying to finish all features in a single window results in the context window rapidly depleting, causing a steep drop in quality towards the latter half.

2. Declaring victory too early In the later stages of complex project development, once the AI agent completes the core functions and has visible output, it directly determines the task is complete and actively terminates—even if a large number of features are unimplemented and core requirements are unmet, it will still stop.

3. Marking features as complete too early As soon as the AI agent finishes writing a feature, it marks it as complete. It will not actively perform end-to-end full functional tests, nor will it verify whether this feature is actually usable in a real environment. It looks like it runs, but in reality, it’s full of hidden bugs.

4. Mechanically copying code patterns AI will mechanically follow existing code patterns (architectural style, coding conventions), even if the pattern is wrong, and continuously amplify it throughout the project. An unconstrained AI agent will accumulate a massive amount of technical debt in a project at extreme speeds.

🛡️ The Four Guardrails of Harness

🔹 1. Context Engineering

The longer and more redundant the AGENTS.MD file is, the lower the Agent’s task success rate, while the inference cost becomes higher. The AGENTS.MD file should be strictly kept under 60 lines.

Context is a scarce resource; too much guidance will crowd out the truly important task code.

🔹 2. Architectural Constraints (The Core)

Implement a strict layered architecture—not by telling the agent “please follow the architecture” via a prompt, but by mechanically enforcing it using deterministic Linters and structured tests.

Embed repair guidelines directly into the Linter error messages, telling the agent how it should be fixed. Constraints are more effective than instructions.

🔹 3. Feedback Loop

In Harness, code review becomes an Agent-to-Agent process. Forming a standardized closed loop: Plan & Discover → Build → Verify → Fix, cycling continuously to consistently purify code quality.

🔹 4. Entropy Management

Over time, AI-generated code accumulates numerous issues: outdated documentation, architectural drift, styling deviations, accumulation of dead code… Letting an Agent maintain documentation for the Agent continuously fights against entropy increase and prevents project rot.

🧭 Conclusion

The evolution of AI programming is essentially a paradigm shift from “writing good prompts” to “building good systems”.

Prompt Engineering solves “how to say it”.
Context Engineering solves “what information to give”.
Harness Engineering solves “how to manage/control it”.

These three paths are not mutually exclusive but rather additive and progressive—each layer builds on the foundation of the previous one. A truly capable AI programming product that stably outputs high-quality code must have invested serious effort across all three of these levels.

LoRA Large Model Fine-Tuning

Thu, 11 Dec 2025 00:00:00 +0800

1. What is LoRA?

LoRA (Low-Rank Adaptation) is a large model fine-tuning technique.

The Problem

Large models (like Qwen, Llama) have 7B, 70B parameters or more. Retraining all parameters every time you want to teach them something new requires dozens of A100 GPUs running for days — far beyond what most people can afford.

The LoRA Approach

Don’t touch the original model — just attach a “small plugin” next to it.

Think of it this way:

Approach	Analogy
Full fine-tuning	Rewriting the entire textbook into your desired version
LoRA	Sticking a few Post-it notes in the margins with your additions

The original model weights are completely unchanged. LoRA inserts a tiny matrix (low-rank matrix) next to certain key layers, and only updates this matrix during training.

Why “Low-Rank Adaptation”?

Mathematically, a large matrix can be approximated by the product of two smaller matrices. LoRA leverages this: the original weight matrix $W$ stays frozen, while two small matrices $A$ and $B$ are trained. The final output becomes $W + A \cdot B$. Together, $A$ and $B$ may be only one-thousandth the size of the original weights.

2. What is LoRA Used For?

Its core ability is simple: change a large model’s “behavior” at very low cost.

📌 LoRA changes style/format/behavior, not knowledge

Want the model to learn new knowledge → Use RAG (Retrieval-Augmented Generation)

Want the model to speak or act differently → Use LoRA

Typical Use Cases

Scenario	Example
Style Transfer	Make a general model write in Lu Xun’s literary style
Format Constraint	Force the model to output strict JSON, nothing more
Role-playing	Turn Qwen into Zhongli from Genshin Impact
Domain Tone	Medical consultation tone, legal document precision
Instruction Following	Make the model better follow system prompts without wandering

LoRA Advantages

Extremely low VRAM: A 7B model can be trained on a single RTX 3090 (24G), or even barely on 8G cards
Tiny file size: Training output is just a few MB. One model can host dozens of different LoRAs, plug-and-play
Fast training: A few hundred samples, results in 30 minutes
No base damage: Unload the LoRA and the model reverts to original, zero risk

3. How to Use LoRA?

Four main steps:

Step 1: Prepare Data

Write example dialogues of the “behavior” you want the model to learn.

Suppose you want the model to become a sarcastic customer service agent. Write 50-200 dialogues like this:

User: Where's my package?
Agent: Well, unless there's a surprise, it's probably sunbathing in the delivery truck. I suggest you sunbathe too while you wait.

User: Can I get a refund?
Agent: Sure, the process is about as long as a pilgrimage. Get your order number ready and I'll guide you on this journey westward.

You don’t need much data — 50-200 high-quality examples will show noticeable results. Quality matters far more than quantity.

Step 2: Choose a Tool

There are many tools out there, but they all do essentially the same thing. Two recommendations:

Tool	Features	Best For
LLaMA-Factory	Web UI, click-based operation	Complete beginners who don’t want to code
Unsloth	2-5x faster, half the VRAM	Those who know some Python and want efficiency

Unsloth’s core code is under 30 lines. The essence: load model → attach LoRA → feed data → train → save.

Step 3: Train

Set a few key parameters, then wait:

Parameter	Purpose	Typical Value
LoRA rank	Determines the “plugin” capacity. Higher = more refined but more VRAM	8 or 16 is enough
Learning rate	How much to learn each step	5e-5, don’t overthink it
Epochs	How many times to go through the data	3-5

Step 4: Use

After training, you get a LoRA file of a few MB. To use it, load both the original model and this LoRA file — the model now behaves as you trained it.

Want to switch back? Just unload the LoRA, one second to restore.

One model can host multiple LoRAs simultaneously — for example, attach a “sarcastic style” LoRA and a “JSON output” LoRA, and the model becomes a sarcastic assistant that outputs JSON.

Concept	What It Does	Relationship with LoRA
Full Fine-tuning	Modifies all parameters	Alternative to LoRA, better results but hundreds of times more expensive
RAG	External knowledge retrieval	Complementary: RAG handles knowledge, LoRA handles style
Prompt Engineering	Writing prompts	Lightest approach, but limited. Use LoRA when prompts aren’t enough
QLoRA	LoRA + 4-bit quantization	VRAM-saving version of LoRA, can run 7B on 8G cards
PEFT	Parameter-Efficient Fine-tuning category	LoRA is the most popular member of the PEFT family

5. One-Sentence Summary

LoRA = a small plugin for large models that changes behavior without changing knowledge, with extremely low training cost and plug-and-play MB-sized files.

MCP Beginner's Guide: The Universal AI Plug Anyone Can Understand

Mon, 01 Dec 2025 01:46:03 +0800

Overview

Have you ever thought: ChatGPT, Claude and other AIs are smart, but they can only chat in a dialog box — they can’t help you check your calendar, manage files, or operate databases because they’re “locked in a cage” with no access to the outside world.

MCP (Model Context Protocol) is here to break down that wall.

Simply put, MCP is an open standard protocol that enables AI applications to connect to external systems — files, databases, APIs, various tools — just like giving AI a universal plug (USB-C port). Plug in anything and it works.

One sentence to understand MCP: It’s the “USB-C port” for the AI world — a unified standard, plug and play.

Why Use MCP?

Before MCP

Before MCP existed, if you wanted to connect AI to external tools (like checking the weather, reading calendars, operating databases), each AI application and each tool required custom integration development.

This was like the early days of phone charging ports — one for Android, one for Apple, one for Type-C. Every time you switched devices, you needed a new cable.

The problems were obvious:

High development costs: Every integration started from scratch
Not universal: Tools written for Claude couldn’t be used by ChatGPT
Difficult to maintain: When a tool was upgraded, all integrations had to be changed

After MCP

MCP defines a unified standard:

Tool providers develop an MCP Server following the MCP standard
AI applications act as MCP Clients to connect to it
As long as both sides follow the MCP protocol, plug and play, no redundant development

This is like how USB-C unified charging ports — one cable to rule them all.

What Can MCP Do? Use Cases at a Glance

1. Personal AI Assistant

Let AI help you manage your daily life:

Connect Google Calendar to check schedules and create meeting reminders
Connect Notion to organize notes and manage to-do lists
Connect Gmail to read and reply to emails
Connect Slack to summarize chat history

Example: You tell the AI “check what meetings I have tomorrow and summarize last week’s project progress notes” — the AI can automatically check your calendar, go through Notion, and give you a summary.

2. Programming & Development

Let AI coding assistants actually “get their hands dirty”:

Connect to the local file system via MCP to read and write project files
Connect to databases to directly query and modify data
Connect to GitHub to automatically create Issues and submit PRs
Connect to Figma to generate code directly from design mockups

Example: Claude Code connects to Figma via MCP, obtains the design mockup, and generates a complete web application.

3. Enterprise Applications

Make a big impact in the corporate world:

Connect to multiple databases so employees can query business data in natural language
Connect to internal systems (CRM, ERP) for AI to automatically compile reports
Connect to knowledge bases so AI can answer questions based on company documentation

4. Creative & Design

Connect to Blender to let AI generate 3D models
Connect to 3D printers to print designs directly
Connect to video editing tools to automate the editing workflow

MCP Core Architecture

MCP’s architecture is very simple, with only three roles:

┌──────────────┐         ┌──────────────┐         ┌──────────────┐
│  AI App      │ ◄─────► │  MCP Protocol │ ◄─────► │ MCP Server   │
│ (MCP Client) │         │ (Transport)   │         │ (External    │
└──────────────┘         └──────────────┘         │  Tool)       │
                                                   └──────────────┘

Role	Description	Analogy
MCP Client	AI applications (Claude, ChatGPT, Cursor)	Phone
MCP Server	Services providing specific capabilities (weather, file management)	Charger
MCP Protocol	The “language” both sides communicate in	USB-C Standard

What Can an MCP Server Provide?

An MCP Server can expose three types of capabilities to AI:

Type	Description	Examples
Tools	Functions/operations AI can call	Search the web, send emails, query databases
Resources	Data AI can read	File contents, database records, API responses
Prompts	Preset prompt templates	Code review templates, translation templates

How to Use MCP?

Method 1: Use Existing MCP Servers (Recommended for Beginners)

This is the simplest approach — others have already written the MCP Server, you just need to “install and connect”.

Step 1: Find the MCP Server You Need

The MCP ecosystem already has a large number of Servers available. Common sources:

Official repository: github.com/modelcontextprotocol/servers
MCP marketplaces: mcp.so, smithery.ai
GitHub search: Search for mcp-server

Popular MCP Servers:

MCP Server	Function
`filesystem`	Read and write local files
`github`	Operate GitHub (Issues, PRs)
`fetch`	Fetch web page content
`sqlite`	Operate SQLite databases
`notion`	Operate Notion notes
`memory`	Persistent memory storage

Step 2: Configure MCP Server in Your AI Application

Using Claude Desktop as an example, find the configuration file:

Windows: %APPDATA%\Claude\claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Add MCP Server configuration (using filesystem as an example):

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/your/work/directory/path"
      ]
    }
  }
}

After saving, restart Claude Desktop, and the AI will have file management capabilities.

Step 3: Start Using

After restarting, simply ask the AI to use these tools in conversation:

“Create a notes folder in my work directory”
“Read the README.md content and give me a summary”
“Search for recent project Issues”

The AI will automatically call the corresponding MCP Server to complete the task.

Method 2: Use MCP in Cursor / VS Code

If you use Cursor or VS Code for programming development, the configuration is similar.

Create .cursor/mcp.json (Cursor) or .vscode/mcp.json (VS Code) in your project root:

{
  "mcpServers": {
    "fetch": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch"]
    },
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sqlite", "./data.db"]
    }
  }
}

After configuration, you can use these tools in AI conversations.

Method 3: Develop Your Own MCP Server (Advanced)

If you want to connect AI to your own systems (like a company’s internal API), you can write your own MCP Server.

MCP supports multiple programming languages with official SDKs:

Language	SDK
TypeScript	`@modelcontextprotocol/sdk`
Python	`mcp` (PyPI)
Java / Kotlin	`io.modelcontextprotocol`

Minimal example (TypeScript):

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "my-server",
  version: "1.0.0"
});

// Define a "check weather" tool
server.tool(
  "get_weather",
  { city: z.string().describe("City name") },
  async ({ city }) => {
    // Your business logic here
    const weather = `${city} is sunny today, 25°C`;
    return {
      content: [{ type: "text", text: weather }]
    };
  }
);

// Start the service
const transport = new StdioServerTransport();
await server.connect(transport);

Once written, configure it in your AI application and start using it.

Which AI Applications Support MCP?

MCP has become an industry standard, with mainstream AI applications offering support:

AI Application	Support Status
Claude Desktop / Claude Code	Native support
ChatGPT	Supported
Cursor	Supported
VS Code (Copilot)	Supported
Windsurf	Supported
OpenCode	Supported

Configure once, use everywhere — an MCP Server configured in Claude will work in other applications too.

FAQ

Q: What’s the difference between MCP and APIs?

An API is a “private protocol” between two parties, with each API having different calling methods. MCP is a unified standard — all tools that follow MCP can be called by AI in the same way. Think of MCP as “a standard API layer specifically for AI.”

Q: Do I need programming skills to use MCP?

No! If you’re just using existing MCP Servers, you only need to know how to copy and paste configuration files. Programming is only needed when developing your own MCP Server.

Q: Is MCP secure?

MCP Servers run locally by default, and data is not uploaded to the cloud. However, when using third-party MCP Servers, it’s recommended to check their source code and permissions to ensure security.

Q: What environment does an MCP Server need to run?

Most MCP Servers run on Node.js, so you need to install Node.js first. Python-based Servers require a Python environment.

Summary

Question	Answer
What is MCP?	A unified standard protocol for AI to connect to external tools
Why use it?	To let AI actually “do work” instead of just chatting
Who can use it?	Everyone — beginners use existing Servers, developers can write their own
How to use it?	Find an MCP Server → Configure it in your AI app → Restart and use

The essence of MCP is: creating a unified “plug standard” for the AI world, allowing tools and AI to connect freely.

Further reading:

MCP Official Documentation

MCP Server Repository

MCP Marketplace

AI Concepts on Yanmu

What Are Agent and Harness? — Video Notes

One-Sentence Summary

1. From ChatGPT to AI Agent

The Original Problem

Manual Improvement

Automated Improvement — Wrapper Sites (Earliest Agent Prototype)

2. Two Core Working Modes of Agent

1. ReAct (Reasoning + Acting) — Step by Step

2. Plan & Execute — Plan First, Then Execute

3. Advanced Agent Capabilities

Tool Calling / Function Calling

Context Management and Compression

Multi-Agent Collaboration

4. Harness — The Safety Net for Reliable AI

Engineering Checkpoints in a Harness

Core Principle of Harness Engineering

5. Complete Architecture Summary

One Sentence to Elevate

Context7 Guide: Help Your AI Coding Assistant Read the Latest Docs

Overview

Why Do You Need It?

💥 One Example Is Enough

With vs Without Context7

🔄 How It Works

Core Capabilities

Smart Matching: You Say the Name, It Finds the Place

Supported Libraries

Version Awareness

Installation

One-Click Install

Manual Configuration

✅ Verification

Usage

Basic Usage

Specify a Library Precisely

Specify a Version

Combine Multiple Libraries

Configure Auto-Trigger

CLI Commands

❓ FAQ

How is this different from AI’s built-in web search?

💰 Will use context7 cost more?

What if my library isn’t listed?

I installed it but it doesn’t work?

Does it affect response speed?

Summary

The Evolution of AI Programming

🤖 The Evolution of AI Programming: From Prompts and Context Engineering to Harness

🧠 Harness Engineering: Deconstructing the Agent into Three Layers

⏳ Harness is Crucial, Why is it Only Getting Popular Now?

① Phase 1: Prompt Engineering

② Phase 2: Context Engineering

③ Phase 3: Harness Engineering

💥 Why Do AI Tasks Fail So Frequently?

🛡️ The Four Guardrails of Harness

🔹 1. Context Engineering

🔹 2. Architectural Constraints (The Core)

🔹 3. Feedback Loop

🔹 4. Entropy Management

🧭 Conclusion

LoRA Large Model Fine-Tuning

1. What is LoRA?

The Problem

The LoRA Approach

Why “Low-Rank Adaptation”?

2. What is LoRA Used For?

Typical Use Cases

LoRA Advantages

3. How to Use LoRA?

Step 1: Prepare Data

Step 2: Choose a Tool

Step 3: Train

Step 4: Use

4. Relationship with Related Concepts

5. One-Sentence Summary

MCP Beginner's Guide: The Universal AI Plug Anyone Can Understand

Overview

Why Use MCP?

Before MCP

💰 Will `use context7` cost more?