Context Engineering cho AI Agents – Tóm tắt từ Anthropic

Posted on October 14, 2025 by Cuong Dinh

Context Engineering cho AI Agents

Tóm tắt từ bài viết của Anthropic về nghệ thuật quản lý context trong phát triển AI

🎯 Context Engineering là gì?

Context Engineering là tập hợp các chiến lược để tuyển chọn và duy trì bộ tokens (thông tin) tối ưu trong quá trình AI agents hoạt động.

Nó bao gồm việc quản lý toàn bộ trạng thái context như:

System prompts (hướng dẫn hệ thống)
Tools (công cụ)
Model Context Protocol (MCP)
External data (dữ liệu bên ngoài)
Message history (lịch sử hội thoại)
Các thông tin khác trong context window

💡 Bản chất: Context Engineering là nghệ thuật và khoa học về việc tuyển chọn thông tin nào sẽ đưa vào context window giới hạn từ vũ trụ thông tin liên tục phát triển của agent.

🔄 Khác biệt giữa Context Engineering và Prompt Engineering

📝 Prompt Engineering

Focus: Cách viết instructions (hướng dẫn)
Phạm vi: Tối ưu hóa system prompts
Use case: Tác vụ đơn lẻ, one-shot
Tính chất: Rời rạc, tĩnh

Ví dụ: “Tóm tắt văn bản này thành 3 điểm chú trọng số liệu tài chính”

🧠 Context Engineering

Focus: Model nhìn thấy gì trong context window
Phạm vi: Toàn bộ trạng thái thông tin
Use case: Multi-turn, tác vụ dài hạn
Tính chất: Lặp lại, động, liên tục

Ví dụ: Quyết định agent nên xem toàn bộ tài liệu, 3 phần cuối, hay bản tóm tắt đã chuẩn bị?

🎭 Ẩn dụ: Prompt engineering là “nói cho ai đó biết phải làm gì”, còn context engineering là “quyết định nên cung cấp nguồn lực gì cho họ”.

⚡ Tại sao Context Engineering quan trọng hơn?

Khi AI agents thực hiện các tác vụ phức tạp trên nhiều vòng lặp, chúng tạo ra ngày càng nhiều dữ liệu. Thông tin này phải được tinh chỉnh theo chu kỳ. Context engineering xảy ra mỗi khi chúng ta quyết định đưa gì vào model – đây là quá trình lặp đi lặp lại, không phải một lần.

⚠️ Những điều cần chú ý khi phát triển AI Agents

1. 🎯 Vấn đề “Goldilocks Zone” cho System Prompts

System prompts cần nằm ở “vùng vừa phải” giữa hai thái cực:

❌ Quá cứng nhắc: Hardcode logic if-else phức tạp → agent dễ vỡ, khó bảo trì

❌ Quá mơ hồ: Hướng dẫn chung chung, giả định context chung → thiếu tín hiệu cụ thể

✅ Vùng tối ưu: Đủ cụ thể để dẫn dắt hành vi, nhưng đủ linh hoạt để cung cấp heuristics mạnh mẽ

2. 🧹 “Context Rot” – Sự suy giảm độ chính xác

Khi context window dài ra, độ chính xác của model giảm xuống:

Giới hạn chú ý: LLMs giống con người – không thể nhớ mọi thứ khi quá tải. Nhiều tokens ≠ chính xác hơn
Context rot: Context càng dài, độ chính xác truy xuất càng giảm. Thêm 100 trang logs có thể che mất chi tiết quan trọng duy nhất
Kiến trúc transformer: Tạo n² mối quan hệ giữa các tokens (10K tokens = 100M quan hệ, 100K tokens = 10B quan hệ)

💡 Giải pháp: Implement pagination, range selection, filtering, truncation với giá trị mặc định hợp lý

3. 🔧 Quản lý Tools hiệu quả

Giữ tools riêng biệt: Không tạo 2 tools cùng làm việc giống nhau (VD: cùng fetch news)
Mô tả rõ ràng: Viết tool descriptions như hướng dẫn nhân viên mới – rõ ràng, tránh mơ hồ
Token-efficient: Giới hạn tool responses (VD: Claude Code giới hạn 25,000 tokens mặc định)
Error handling tốt: Error messages phải cụ thể, actionable, không phải error codes mơ hồ

4. 📊 Just-in-Time Context Retrieval

Thay vì load toàn bộ dữ liệu trước, hãy fetch dữ liệu động khi cần:

Tránh overload context window
Giảm token costs
Ngăn context poisoning (nhiễu thông tin)
Tương tự cách con người dùng hệ thống indexing bên ngoài

5. 🎨 Ba chiến lược cho tác vụ dài hạn

📦 Compaction (Nén thông tin)

Tóm tắt context cũ, giữ lại thông tin quan trọng

📝 Structured Note-Taking

Agent tự ghi chú có cấu trúc về những gì đã làm

🤖 Multi-Agent Architecture

Spawn sub-agents nhỏ cho các tác vụ hẹp, trả về kết quả ngắn gọn

6. 🎯 Ưu tiên Context theo tầm quan trọng

🔴 High Priority (luôn có trong context): Tác vụ hiện tại, kết quả tool gần đây, hướng dẫn quan trọng

🟡 Medium Priority (khi có không gian): Examples, quyết định lịch sử

⚪ Low Priority (on-demand): Nội dung file đầy đủ, documentation mở rộng

7. 📈 Monitoring và Iteration

Theo dõi liên tục:

Token usage per turn
Tool call frequency
Context window utilization
Performance ở các độ dài context khác nhau
Recall vs Precision khi rút gọn context

💡 Quy trình: Bắt đầu đơn giản → Test → Xác định lỗi → Thêm hướng dẫn cụ thể → Loại bỏ redundancy → Lặp lại

💡 Kết luận

Context engineering là kỹ năng then chốt để xây dựng AI agents hiệu quả. Khác với prompt engineering tập trung vào “cách viết instructions”, context engineering quan tâm đến “môi trường thông tin toàn diện” mà agent hoạt động.

Thành công không nằm ở việc tìm từ ngữ hoàn hảo, mà là tối ưu hóa cấu hình context để tạo ra hành vi mong muốn một cách nhất quán.

🎯 Nguyên tắc cốt lõi: Tìm bộ tokens nhỏ nhất có tín hiệu cao nhất để tối đa hóa khả năng đạt được kết quả mong muốn. Mỗi từ không cần thiết, mỗi mô tả tool thừa, mỗi dữ liệu cũ đều làm giảm hiệu suất agent.

Revolutionizing Test Automation with Playwright Agents

Posted on October 14, 2025October 14, 2025 by Cuong Dinh

🎭 Revolutionizing Test Automation with Playwright Agents

How AI-Powered Agents are Transforming E2E Testing

📅 October 2025
⏱️ 5 min read
🏷️ Testing, AI, Automation

Imagine this: You describe what you want to test, and AI generates comprehensive test plans, writes the actual test code, and even fixes failing tests automatically. This isn’t science fiction—it’s Playwright Agents, and it’s available today.

Playwright has introduced three powerful AI agents that work together to revolutionize how we approach test automation: the Planner, Generator, and Healer. Let’s dive deep into how these agents are changing the game.

What Are Playwright Agents?

Playwright Agents are AI-powered tools that automate the entire test creation and maintenance lifecycle. They can work independently or sequentially in an agentic loop, producing comprehensive test coverage for your product without the traditional manual overhead.

🎯

Planner Agent

The Planner is your AI test strategist. It explores your application and produces detailed, human-readable test plans in Markdown format.

How It Works:

Input: A clear request (e.g., “Generate a plan for guest checkout”), a seed test that sets up your environment, and optionally a Product Requirements Document
Process: Runs the seed test to understand your app’s structure, analyzes user flows, and identifies test scenarios
Output: Structured Markdown test plans saved in specs/ directory with detailed steps and expected results

💡 Pro Tip: The Planner uses your seed test as context, so it understands your custom fixtures, authentication flows, and project setup automatically!

Example Output:

# TodoMVC Application - Basic Operations Test Plan

## Test Scenarios

### 1. Adding New Todos
#### 1.1 Add Valid Todo
**Steps:**
1. Click in the "What needs to be done?" input field
2. Type "Buy groceries"
3. Press Enter key

**Expected Results:**
- Todo appears in the list with unchecked checkbox
- Counter shows "1 item left"
- Input field is cleared and ready for next entry

⚡

Generator Agent

The Generator transforms your human-readable test plans into executable Playwright test code, verifying selectors and assertions in real-time.

Key Features:

Live Verification: Checks selectors against your actual app while generating code
Smart Assertions: Uses Playwright’s catalog of assertions for robust validation
Context Aware: Inherits setup from seed tests and maintains consistency
Best Practices: Generates code following Playwright conventions and modern patterns

Generated Test Example:

// spec: specs/basic-operations.md
// seed: tests/seed.spec.ts
import { test, expect } from '../fixtures';

test.describe('Adding New Todos', () => {
  test('Add Valid Todo', async ({ page }) => {
    // Type and submit todo
    const todoInput = page.getByRole('textbox', { 
      name: 'What needs to be done?' 
    });
    await todoInput.fill('Buy groceries');
    await todoInput.press('Enter');
    
    // Verify todo appears
    await expect(page.getByText('Buy groceries')).toBeVisible();
    await expect(page.getByText('1 item left')).toBeVisible();
    await expect(todoInput).toHaveValue('');
  });
});

🔧

Healer Agent

The Healer is your automated maintenance engineer. When tests fail, it diagnoses issues and applies fixes automatically.

Healing Process:

Step 1: Replays the failing test steps to understand the failure context
Step 2: Inspects the current UI to locate equivalent elements or alternative flows
Step 3: Suggests patches like locator updates, wait adjustments, or data corrections
Step 4: Re-runs the test until it passes or determines the functionality is actually broken

🎯 Smart Decisions: If the Healer can’t fix a test after multiple attempts, it marks the test as skipped and flags it as a potential real bug in your application!

Common Fixes Applied:

Updating selectors when UI structure changes
Adding appropriate waits for dynamic content
Adjusting test data to match new requirements
Handling new dialog boxes or pop-ups

🤖 Working with Claude Code

Playwright Agents integrate seamlessly with Claude Code, enabling natural language test automation directly from your terminal.

Setup Process:

# Initialize Playwright Agents for Claude Code
npx playwright init-agents --loop=claude

# This generates agent definitions optimized for Claude Code
# under .github/ directory with MCP tools and instructions

1
Initialize: Run the init command to generate agent definitions

2
Plan: Ask Claude Code to use the Planner: “Use 🎭 planner to create a test plan for user registration”

3
Generate: Command the Generator: “Use 🎭 generator to create tests from specs/registration.md”

4
Heal: Let the Healer fix issues: “Use 🎭 healer to fix all failing tests”

Benefits with Claude Code:

Natural Language Control: Command agents using simple English instructions
Context Awareness: Claude Code understands your project structure and requirements
Iterative Refinement: Easily adjust and improve tests through conversation
Automatic Updates: Regenerate agents when Playwright updates to get latest features

The Complete Workflow

Here’s how the three agents work together to create comprehensive test coverage:

1. 🎯 Planner explores your app
   └─> Produces: specs/user-flows.md

2. ⚡ Generator reads the plan
   └─> Produces: tests/user-registration.spec.ts
               tests/user-login.spec.ts
               tests/checkout.spec.ts

3. Run tests: npx playwright test
   └─> Some tests fail due to UI changes

4. 🔧 Healer analyzes failures
   └─> Updates selectors automatically
   └─> Tests now pass ✅

Why This Matters

Traditional E2E testing requires significant manual effort:

Writing detailed test plans takes hours
Converting plans to code is tedious and error-prone
Maintaining tests as UI changes is a constant battle
New team members need extensive training

Playwright Agents eliminate these pain points by:

✅ Generating plans in minutes instead of hours
✅ Producing production-ready test code automatically
✅ Self-healing tests that adapt to UI changes
✅ Making test automation accessible to everyoneDEMO:

Github source : https://github.com/cuongdvscuti/agent-playwright

Ready to Transform Your Testing?

Playwright Agents represent a fundamental shift in how we approach test automation. By combining AI with Playwright’s powerful testing capabilities, you can achieve comprehensive test coverage with a fraction of the traditional effort.

Whether you’re starting a new project or maintaining an existing test suite, Playwright Agents can help you move faster, catch more bugs, and spend less time on maintenance.

Get Started with Playwright Agents

📚 Documentation

🐙 GitHub Repo

💬 Discord Community

Chrome DevTools MCP – Khi AI Browser Biết Debug, Chu Trình Phát Triển Được Hoàn Thiện

Posted on October 8, 2025 by Thưởng Đồng

Các công cụ AI như ChatGPT, Copilot, Claude hay Cursor hiện nay có thể viết code rất nhanh, thậm chí tạo nguyên một giao diện chỉ với vài dòng mô tả.
Nhưng chúng vẫn có một điểm mù rất lớn:
👉 Chúng không nhìn thấy trang web thực tế đang chạy.

Điều đó có nghĩa là, AI có thể viết code HTML/CSS/JS, nhưng không biết nút có nằm đúng chỗ không, form có lỗi console không, hay website có chạy chậm không.
Tất cả phần kiểm tra, test, debug… vẫn phải do con người làm.

Và đó chính là điều Chrome DevTools MCP muốn thay đổi.

⚙️ Chrome DevTools MCP là gì?

MCP (Model Context Protocol) là một giao thức mới của Google, cho phép AI có thể “kết nối” trực tiếp với các công cụ phát triển – như Chrome DevTools – để quan sát và tương tác với trình duyệt thật.

Nói đơn giản:

Nếu trước đây AI chỉ “đoán” xem code chạy ra sao, thì giờ đây nó có thể “mở Chrome, xem kết quả thật, đọc log, và tự sửa lỗi”.

Với Chrome DevTools MCP, một AI agent có thể:

Mở một trang web và xem console log
Phân tích hiệu suất tải trang (load chậm ở đâu, hình ảnh nào quá nặng…)
Tự chạy thử hành động người dùng: click, nhập form, chuyển trang
Phát hiện lỗi và đề xuất cách sửa

Tất cả diễn ra trong một vòng lặp tự động — gần như một lập trình viên đang ngồi test website.

🔍 Cách Chrome DevTools MCP hoạt động (hiểu đơn giản thôi)

MCP hoạt động như một “người phiên dịch” giữa AI và Chrome.

Khi AI muốn kiểm tra website, nó gửi yêu cầu đến MCP server.
MCP dùng Chrome DevTools Protocol để điều khiển Chrome thật: mở tab, đọc DOM, xem console, lấy dữ liệu mạng…
MCP sau đó trả kết quả lại cho AI để phân tích.

Ví dụ thực tế:

AI có thể yêu cầu “Mở trang example.com, xem có lỗi JavaScript nào trong console không, và nếu có thì sửa code CSS/JS cho đúng.”

🚀 Lợi ích mang lại

1️⃣ AI không còn “đoán mò”

Trước đây AI viết code dựa vào kinh nghiệm huấn luyện, chứ không biết kết quả thực tế.
Giờ đây, nó thấy được lỗi, đọc được log, biết website load chậm ở đâu, và có thể tự học từ đó.

2️⃣ Giảm thời gian debug cho developer

Thay vì “viết – chạy – sửa – reload” thủ công, AI có thể tự kiểm tra và gợi ý fix ngay sau khi sinh code.

3️⃣ Website nhanh và ổn định hơn

AI có thể tự đánh giá hiệu suất (Core Web Vitals, LCP, CLS…) và đề xuất tối ưu: nén ảnh, lazy-load, tối ưu script…

4️⃣ Tạo nền tảng cho “AI browser” tương lai

Những trình duyệt như Arc, Brave, hoặc Chrome AI hoàn toàn có thể tích hợp MCP để cho phép AI tự test và sửa trang web ngay trong trình duyệt.

🧩 Hướng dẫn nhanh để thử MCP

⚠️ MCP vẫn đang ở giai đoạn thử nghiệm (preview), nên có thể lỗi nhẹ.
Dưới đây là hướng dẫn dành cho những ai muốn khám phá:

Cách cài đặt:

Nếu bạn thấy dòng:

→ Là thành công! 🎉

Bây giờ, bạn có thể kết nối AI (như Claude, Gemini, hoặc Cursor) tới server MCP này để thử nghiệm các lệnh như:

“Kiểm tra lỗi console trên trang web này.”
“Phân tích lý do vì sao trang load chậm.”
“Chụp ảnh màn hình trang và mô tả bố cục.”

⚠️ Một vài thách thức

MCP hiện chỉ hoạt động với Chrome / Chromium.
Cần Node 22+ (phiên bản cũ sẽ lỗi).
Một số lệnh DevTools chưa được hỗ trợ đầy đủ.
Khi chạy cần đảm bảo bảo mật dữ liệu, vì AI có thể truy cập nội dung trang web.

🌈 Tương lai: AI Developer thật sự đang đến gần

Chrome DevTools MCP đánh dấu bước tiến lớn trong việc “AI hóa” toàn bộ chu trình phát triển phần mềm.

Trước đây, AI chỉ viết code.
Giờ đây, AI viết – kiểm tra – phân tích – sửa lỗi – tối ưu.
Một chu trình phát triển trọn vẹn.

Không xa nữa, chúng ta có thể tưởng tượng ra:

Một AI browser có thể tự chẩn đoán lỗi web.
Một AI tester tự động tạo và chạy test case thực tế.
Và thậm chí, một AI developer có thể deploy web mà không cần mở DevTools bằng tay.

✨ Kết luận

Chrome DevTools MCP không chỉ là một công cụ debug mới — mà là bước khởi đầu của kỷ nguyên AI Developer thực thụ.
Với khả năng quan sát, thử nghiệm và phản hồi trong môi trường thật, AI không chỉ là “người viết code”, mà dần trở thành “người đồng hành” trong cả quá trình phát triển.

Serena: Transform Any LLM Into a Professional Coding Agent – Save 80% Tokens, 5x Faster Development

Posted on September 22, 2025September 22, 2025 by hello@scuti

Bạn đã bao giờ ước có một trợ lý lập trình thực sự hiểu codebase của mình, không chỉ đọc file dài dòng hay grep chuỗi, mà còn làm việc như một IDE ngay trong tay?

Đó chính là điều mà Serena mang lại.

Serena là gì?

Serena là một toolkit mạnh mẽ dành cho coding agent, có thể biến bất kỳ LLM nào bạn đang dùng thành một agent giàu tính năng, làm việc trực tiếp trên codebase. Khác với nhiều công cụ hiện tại, Serena không bị ràng buộc vào một LLM, framework hay giao diện cụ thể – bạn có thể linh hoạt sử dụng trong nhiều bối cảnh khác nhau.

🔧 Với Serena, agent của bạn có thể:

Truy xuất và chỉnh sửa code ở mức symbol, thay vì phải đọc toàn bộ file
Hiểu được mối quan hệ giữa các thành phần code, như cách một IDE chuyên nghiệp hoạt động
Tối ưu hiệu suất (token efficiency) khi làm việc với LLM, tiết kiệm chi phí và tăng tốc độ

🆓 Hoàn toàn miễn phí & mã nguồn mở

Serena giúp bạn khai thác tối đa khả năng của các LLM mà không tốn thêm chi phí.

Tại sao Serena quan trọng?

Hãy nghĩ về Serena như việc trao cho coding agent của bạn một “bộ công cụ IDE”: từ find_symbol, find_referencing_symbols cho đến insert_after_symbol. Điều này mở ra một kỷ nguyên mới, nơi việc tự động hóa code không chỉ dừng lại ở “tìm & thay thế chuỗi”, mà là hiểu và chỉnh sửa code như một lập trình viên thực thụ.

Cách hoạt động

Serena bản thân nó không phải là một “AI biết code” – mà là bộ công cụ giúp AI code tốt hơn. Để thực sự hoạt động, Serena cần một LLM (như Claude, GPT, Gemini…) làm “bộ não” để điều phối việc sử dụng công cụ.

Ví dụ đơn giản: bạn có thể supercharge Claude Code chỉ với một dòng lệnh trong terminal, và ngay lập tức Claude sẽ được bổ sung khả năng thao tác codebase ở mức IDE.

So sánh Workflow: Trước và Sau Serena

Tiêu chí	Trước khi dùng Serena	Với Serena
Cách tìm mã cần chỉnh sửa	LLM phải đọc cả file hoặc cả codebase, sau đó “đoán” vị trí cần thay đổi	Sử dụng công cụ như `find_symbol`, `find_referencing_symbols` để nhảy thẳng tới đoạn mã cần thao tác
Hiệu quả token	Tiêu tốn nhiều token do phải nạp cả khối lượng mã lớn	Tiết kiệm token, chỉ truy xuất phần liên quan
Tốc độ	Chậm, vì cần nhiều bước suy luận và thao tác thủ công	Nhanh hơn, nhờ thao tác trực tiếp ở mức symbol
Chất lượng mã sinh ra	Dễ bị lỗi do LLM có thể bỏ sót ngữ cảnh quan trọng hoặc chỉnh sai chỗ	Ổn định và chính xác hơn, nhờ cơ chế truy xuất có cấu trúc
Ứng dụng thực tế	Chỉ phù hợp cho dự án nhỏ	Cực kỳ hữu ích cho dự án lớn, nhiều module phức tạp

Công nghệ đằng sau Serena

Serena được xây dựng dựa trên Language Server Protocol (LSP) – chuẩn chung mà hầu hết các IDE hiện đại đều sử dụng. Nhờ đó, Serena không chỉ đọc code ở mức văn bản, mà còn hiểu được cấu trúc và ngữ nghĩa của mã nguồn: class, function, reference, symbol…

Tương tự như một developer đang thao tác trong IDE, Serena có thể:

Nhanh chóng tìm đúng context trong dự án lớn
Thực hiện chỉnh sửa có chủ đích, thay vì tìm kiếm chuỗi mù quáng
Giúp tiết kiệm token, tăng tốc độ và giảm lỗi khi kết hợp cùng LLM

💡 Kết quả: Serena thường mang lại hiệu quả cao hơn cả những giải pháp thương mại đắt đỏ, nhưng hoàn toàn miễn phí & open-source.

Ngôn ngữ được hỗ trợ

Ngôn ngữ	Ghi chú
Python	Hỗ trợ trực tiếp
TypeScript / JavaScript	Hỗ trợ trực tiếp
PHP	Dùng Intelephense LSP (cần INTELEPHENSE_LICENSE_KEY cho tính năng premium)
Go	Cần cài gopls
R	Cần cài package languageserver
Rust	Dùng rust-analyzer qua rustup
C / C++	Một số vấn đề khi tìm references (đang cải thiện)
Zig	Cần cài ZLS
C#	Hỗ trợ trực tiếp
Ruby	Mặc định dùng ruby-lsp (có thể chọn solargraph cũ)
Swift	Hỗ trợ trực tiếp
Kotlin	Dùng LS chính thức (pre-alpha, còn lỗi)
Java	Startup chậm, có vấn đề trên macOS/Linux
Clojure	Hỗ trợ trực tiếp
Dart	Hỗ trợ trực tiếp
Bash	Hỗ trợ trực tiếp
Lua	Tự động tải lua-language-server nếu chưa có
Nix	Cần cài nixd
Elixir	Cần NextLS + Elixir (chưa hỗ trợ Windows)
Erlang	Cần beam + erlang_ls, experimental, có thể chậm
AL	Hỗ trợ trực tiếp

Cách tích hợp Serena với LLM

Serena được thiết kế linh hoạt, có thể cắm vào nhiều môi trường và workflow khác nhau:

🔹 Qua Model Context Protocol (MCP)

Serena chạy như một MCP server, dễ dàng tích hợp với:

🖥 IDEs: VSCode, Cursor, IntelliJ
🧩 Extensions: Cline, Roo Code
💻 Terminal clients: Codex, Gemini-CLI, Qwen3-Coder, rovodev, OpenHands CLI
🪄 Claude Code và Claude Desktop
🌐 Local clients: OpenWebUI, Jan, Agno

🔹 Qua mcpo (bridge tool)

Dùng để kết nối Serena với những client không hỗ trợ MCP, nhưng có hỗ trợ tool calling qua OpenAPI (ví dụ ChatGPT).

🔹 Nhúng trực tiếp vào agent framework

Các tool trong Serena được xây dựng độc lập với framework → bạn có thể đưa vào bất kỳ agent framework nào (LangChain, LlamaIndex, v.v.), như một “plugin” chuyên về code.

💡 Điểm mạnh: Serena không khóa bạn vào một LLM hay IDE cụ thể. Dù bạn dùng ChatGPT, Claude, Gemini hay bất kỳ model nào, Serena đều có thể biến LLM đó thành một coding agent mạnh mẽ.

Hướng dẫn cài đặt Serena MCP trên Cursor (macOS)

🔹 Bước 1: Cài đặt uvx

Chạy lệnh trong Terminal:

brew install uvx

🔹 Bước 2: Thêm Serena MCP vào Cursor

Mở Cursor Settings
Vào mục MCP → Thêm mới MCP
Trong file mcp.json, thêm cấu hình sau:

{
  "mcpServers": {
    "serena": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/oraios/serena",
        "serena",
        "start-mcp-server",
        "--context",
        "ide-assistant"
      ]
    }
  }
}

🔹 Bước 3: Kiểm tra Serena đã chạy thành công

Sau khi restart Cursor, Serena MCP server sẽ được khởi động tại localhost
Bạn có thể mở trình duyệt và truy cập: 👉 http://127.0.0.1:24282/dashboard/index.html
Tại đây sẽ hiển thị dashboard của Serena, xác nhận rằng server đã chạy

⚡️ Giờ thì bạn có thể bắt đầu sử dụng Serena trực tiếp trong Cursor, tận dụng các công cụ phân tích code và chỉnh sửa thông minh giống như IDE xịn + AI hỗ trợ.

Bắt đầu sử dụng Serena trong Cursor

1. Kiểm tra Serena đã kết nối

Mở Command Palette (⌘ + Shift + P)
Gõ:
- MCP: List Tools → để xem danh sách tool mà Serena cung cấp
- MCP: Call Tool → để gọi trực tiếp một tool bất kỳ từ Serena

Nếu bạn thấy các tool này, nghĩa là Serena đã được kết nối thành công.

2. Index dự án với Serena (Bước quan trọng)

Mở chat với AI và nhập lệnh:

"Use Serena to index the entire project."

Chờ Serena hoàn tất indexing (tùy project lớn/nhỏ sẽ nhanh hay chậm)
Sau khi indexing xong, Serena sẽ hiểu toàn bộ codebase ở mức symbol-level

3. Chat AI trong Cursor với Serena

Không dùng Serena (AI tự đoán):

"Find where process_audio_file_url is used."

Dùng Serena (AI gọi đúng tool):

"Use Serena to find where process_audio_file_url is referenced."
"Insert a new function after the UserService class using Serena."

Quan sát: Thay vì đọc toàn file, AI sẽ gọi Serena để tìm chính xác vị trí cần chỉnh sửa → tiết kiệm token, nhanh hơn và code chất lượng hơn.

Hiểu về thư mục `memories/`

Sau khi dùng “Use Serena to index the entire project.”, Cursor sẽ có thêm 1 thư mục memories/.

📂 Thư mục memories dùng để làm gì?

Khi bạn bảo Serena index dự án, nó sẽ quét toàn bộ codebase và trích xuất ra thông tin ở mức symbol-level (class, function, biến, module, dependency, …). Những dữ liệu này không chỉ dùng trong một session, mà được lưu trữ lại trong thư mục memories/ để tái sử dụng.

🔹 Chức năng chính của thư mục memories

Lưu trữ index codebase đã phân tích
- Thay vì phải index lại toàn bộ project mỗi lần mở Cursor, Serena sẽ đọc từ memories/ để tiết kiệm thời gian
- Với project lớn (hàng nghìn file), điều này cực kỳ quan trọng
Giúp Serena “ghi nhớ” ngữ cảnh codebase qua nhiều phiên làm việc
- Cho phép Serena hiểu liên kết giữa các file, dependency, và symbol
- Nhờ đó khi bạn quay lại project, Serena vẫn có thể truy vấn chính xác mà không cần quét lại từ đầu
Tăng tốc độ tìm kiếm và chỉnh sửa code
- Khi bạn gọi tool như find_symbol, Serena sẽ tìm trực tiếp trong dữ liệu memories thay vì đọc toàn bộ file
- Điều này làm giảm đáng kể chi phí token và cải thiện tốc độ phản hồi
Cơ chế cập nhật thông minh
- Nếu bạn chỉnh sửa hoặc thêm file mới, Serena có thể cập nhật lại memories (re-index incrementally) thay vì làm lại toàn bộ
- Giúp giữ bộ nhớ luôn đồng bộ với trạng thái codebase hiện tại

🔹 Khi nào cần xoá hoặc làm mới memories/?

Khi project có thay đổi cấu trúc lớn (ví dụ: đổi tên thư mục gốc, refactor nhiều module cùng lúc)
Khi Serena trả về kết quả sai lệch → có thể do bộ nhớ cũ. Lúc này chỉ cần xóa thư mục memories/ và chạy lại indexing

👉 Nói đơn giản: memories là “bộ não dài hạn” của Serena. Nó cho phép AI làm việc hiệu quả như một IDE, không mất công quét lại dự án mỗi lần bạn mở Cursor.

Quản lý & Làm mới thư mục memories

Đôi khi project thay đổi nhiều, hoặc Serena trả kết quả chưa chính xác → bạn có thể cần làm mới (refresh) thư mục memories/.

🔹 1. Re-index toàn bộ project

Trong chat với AI trong Cursor, gõ:

"Use Serena to re-index the entire project."

Serena sẽ xoá index cũ trong memories/ và quét lại toàn bộ codebase.

🔹 2. Cập nhật incremental (khi thêm file/hàm mới)

Nếu bạn chỉ thêm vài file mới hoặc sửa một phần nhỏ, không cần index lại hết. Hãy chat với AI:

"Use Serena to update index for changed files only."

Serena sẽ scan phần thay đổi và cập nhật lại memories/ thay vì làm lại từ đầu.

🔹 3. Xoá thủ công thư mục memories/

Trong trường hợp nghi ngờ index bị lỗi hoặc không đồng bộ:

Thoát Cursor
Xoá thư mục memories/ trong project: rm -rf memories
Mở lại Cursor và yêu cầu: "Use Serena to index the entire project."

→ Serena sẽ tạo lại bộ nhớ mới sạch sẽ.

✅ Khi nào nên refresh memories?

Project refactor lớn, đổi cấu trúc folder
Serena tìm nhầm symbol hoặc không thấy hàm/class mới thêm
Project import dependency mới hoặc xoá nhiều module cũ

Case Study: Serena thay đổi game như thế nào? 🚀

1. Câu chuyện thực tế

Trong dự án Realtime Translator của công ty, mình sử dụng Claude 4 để hỗ trợ code (sau 2 tuấn để test và thực nghiệm) . Claude 4 rất mạnh về suy luận và viết code, nhưng có một nhược điểm chí mạng: ngốn token khủng khiếp.

Trước khi dùng Serena → chỉ 7 ngày là đã hết quota. Sau khi dùng Serena → tận 2 tuần vẫn chưa hết quota.

Tại sao? Vì mỗi lần yêu cầu AI chỉnh sửa code, nó phải “cày” qua hàng ngàn dòng code không liên quan, đọc cả những file chẳng liên quan gì đến yêu cầu.

👉 Điều này dẫn đến:

Tốn token vô ích
Phản hồi chậm
Độ chính xác giảm vì ngữ cảnh bị nhiễu loạn

Serena ra đời chính là để giải quyết nỗi đau này!

2. Những lợi ích cụ thể

🔥 Hiệu suất & độ chính xác vượt trội

AI không còn bị “ngợp” bởi hàng đống code vô nghĩa. Ngữ cảnh gọn gàng → phản hồi nhanh, chính xác, ít nhầm lẫn.

💸 Tiết kiệm chi phí và tokens

Thay vì để AI đọc cả codebase, chỉ những phần liên quan mới được đưa vào. Với các mô hình tính phí dựa trên token (như Claude, GPT-4), bạn sẽ tiết kiệm được một khoản lớn.

Cá nhân mình dùng Claude Code Pro ($17), trước kia rất dễ chạm limit. Từ ngày có Serena → vẫn còn chạm limit, nhưng đã cải thiện đáng kể

Lưu ý quan trọng khi sử dụng Serena

🔹 Cài đặt theo từng dự án

Serena nên được cài theo từng dự án (per-project)
Không nên cài ở scope “user” vì dữ liệu index có thể bị lẫn lộn giữa các project
Mỗi khi chuyển project, hãy đảm bảo Serena được cấu hình riêng biệt

🔹 Indexing định kỳ

Với project thay đổi thường xuyên, nên re-index ít nhất 1 tuần/lần
Khi add/remove nhiều dependency, luôn chạy lại indexing

🔹 Monitoring hiệu suất

Theo dõi dashboard Serena để đảm bảo server hoạt động ổn định
Nếu thấy phản hồi chậm, kiểm tra lại cấu hình MCP và memory usage

Kết luận

Serena không chỉ là một công cụ, mà là một game changer cho cách chúng ta làm việc với AI trong lập trình. Bằng cách biến LLM thành một coding agent thực sự hiểu codebase, Serena mở ra những khả năng mới:

Tiết kiệm chi phí đáng kể khi sử dụng LLM
Tăng tốc độ và độ chính xác trong các tác vụ coding
Mở rộng khả năng của AI từ “code generator” thành “code collaborator”

Và quan trọng nhất, tất cả điều này đều hoàn toàn miễn phí và mã nguồn mở.

👉 Hành động ngay hôm nay: Hãy thử cài đặt Serena cho project của bạn và trải nghiệm sự khác biệt. Bạn sẽ ngạc nhiên về hiệu quả mà nó mang lại!

Bài viết được viết dựa trên trải nghiệm thực tế sử dụng Serena trong các dự án production. Để biết thêm thông tin chi tiết và cập nhật mới nhất, hãy truy cập GitHub repository của Serena.