# Bài 10: Tổng kết khóa học

> **Revit API x MCP x AI** — Nhìn lại hành trình, kiến trúc hoàn chỉnh và hướng phát triển tương lai
>
> **Khóa học:** Revit API x MCP x AI — Từ Zero đến Plugin hoàn chỉnh **Bài học:** 10/10 — Tổng kết khóa học **Thời gian đọc:** \~25 phút **Mã nguồn tham khảo:** [deepbim-revit-mcp-plugin](https://github.com/nguyenngocdue/deepbim-revit-mcp-plugin) **Tham chiếu triển khai Tool/MCP Server:** [revit-mcp-server](https://github.com/nguyenngocdue/revit-mcp-server)

***

## Mục lục

1. [Lời mở đầu bài học cuối](#lời-mở-đầu-bài-học-cuối)
2. [Nhìn lại hành trình 10 bài học](#nhìn-lại-hành-trình-10-bài-học)
3. [Kiến trúc hoàn chỉnh — Sơ đồ tổng thể](#kiến-trúc-hoàn-chỉnh--sơ-đồ-tổng-thể)
4. [MCP nâng cao: Resources](#mcp-nâng-cao-resources)
5. [MCP nâng cao: Prompts](#mcp-nâng-cao-prompts)
6. [MCP nâng cao: Sampling](#mcp-nâng-cao-sampling)
7. [Mở rộng sang phần mềm khác](#mở-rộng-sang-phần-mềm-khác)
8. [Ý tưởng dự án thực tế](#ý-tưởng-dự-án-thực-tế)
9. [Lộ trình phát triển tương lai](#lộ-trình-phát-triển-tương-lai)
10. [Câu hỏi tự suy nghĩ](#câu-hỏi-tự-suy-nghĩ)
11. [Cộng đồng và đóng góp](#cộng-đồng-và-đóng-góp)
12. [Lời kết truyền cảm hứng](#lời-kết-truyền-cảm-hứng)
13. [Tài liệu tham khảo](#tài-liệu-tham-khảo)

***

## Lời mở đầu bài học cuối

Chào mừng bạn đến với **bài học cuối cùng** của khóa học **"Revit API x MCP x AI — Từ Zero đến Plugin hoàn chỉnh"**.

Bạn đã đi được một hành trình dài. Từ bài học đầu tiên — khi MCP còn là một khái niệm xa lạ — đến ngày hôm nay, bạn đã có trong tay một hệ thống hoàn chỉnh kết nối trí tuệ nhân tạo với phần mềm thiết kế xây dựng chuyên nghiệp nhất thế giới.

Bài học này sẽ giúp bạn:

* **Nhìn lại toàn bộ hành trình** — Tóm tắt kiến thức từ Bài 1 đến Bài 9
* **Hiểu kiến trúc tổng thể** — Sơ đồ hoàn chỉnh của hệ thống
* **Khám phá MCP nâng cao** — Resources, Prompts, Sampling với code mẫu TypeScript
* **Mở rộng tầm nhìn** — Kết nối thêm Navisworks, Tekla Structures, AutoCAD
* **Định hướng tương lai** — Ý tưởng dự án thực tế và đóng góp cộng đồng

> *"Học không chỉ là tiếp thu kiến thức, mà là khả năng áp dụng kiến thức đó vào thực tế."*

***

## Nhìn lại hành trình 10 bài học

Trước khi đi sâu vào các chủ đề nâng cao, hãy cùng nhìn lại những gì chúng ta đã trải qua. Mỗi bài học là một bước tiến quan trọng trong việc xây dựng hệ thống kết nối AI với Revit.

### Dòng thời gian học tập

```mermaid
timeline
    title Hành trình học tập — Revit API x MCP x AI
    section Nền tảng
        Bài 1 : Giới thiệu tổng quan MCP
               : Revit API và kiến trúc hệ thống
        Bài 2 : Demo kết nối thực tiễn
               : Luồng dữ liệu end-to-end
    section Xây dựng thành phần
        Bài 3 : Triển khai Tool cơ bản
               : Revit API với C#
        Bài 4 : Dựng MCP Server
               : Node.js và MCP SDK
        Bài 5 : Core MCP cho Revit
               : HTTP Listener trong C# Plugin
    section Kết nối và vận hành
        Bài 6 : Cấu hình chuẩn bị kết nối
               : VS Code và Claude Code
        Bài 7 : Kết nối tất cả lại với nhau
               : Khoảnh khắc "It works!"
    section Nâng cao và hoàn thiện
        Bài 8 : Mở rộng — Viết thêm Tool mới
               : Prompt engineering cho BIM
        Bài 9 : Đóng gói Plugin để phân phối
               : Build Release và Installer
        Bài 10 : Tổng kết khóa học
                : Hướng phát triển tương lai
```

### Tóm tắt từng bài học

| Bài    | Chủ đề                    | Kết quả đạt được                                                     |
| ------ | ------------------------- | -------------------------------------------------------------------- |
| **1**  | Giới thiệu tổng quan      | Hiểu MCP là gì, Revit API là gì, kiến trúc tổng thể hệ thống         |
| **2**  | Demo kết nối thực tiễn    | Thấy được AI ra lệnh cho Revit tạo tường, đọc model                  |
| **3**  | Tool cơ bản với Revit API | Viết được tool C# đầu tiên — `GetWalls` với FilteredElementCollector |
| **4**  | MCP Server (Node.js)      | Dựng được MCP Server với `@modelcontextprotocol/sdk`                 |
| **5**  | Core MCP cho Revit (C#)   | Viết HTTP Listener trong Revit plugin, xử lý External Event          |
| **6**  | Chuẩn bị kết nối          | Cấu hình VS Code, Claude Code, kiểm tra checklist sẵn sàng           |
| **7**  | Kết nối toàn bộ           | Chạy end-to-end: prompt → AI → MCP → Revit → kết quả                 |
| **8**  | Mở rộng Tool              | Viết thêm `get_rooms`, `create_column`, prompt engineering           |
| **9**  | Đóng gói Plugin           | Build Release, tạo Installer, cấu trúc phân phối chuyên nghiệp       |
| **10** | Tổng kết                  | Kiến trúc hoàn chỉnh, MCP nâng cao, hướng phát triển                 |

***

## Kiến trúc hoàn chỉnh — Sơ đồ tổng thể

Đây là sơ đồ tổng thể của hệ thống mà bạn đã xây dựng xuyên suốt khóa học. Nhìn lại nó với con mắt của người đã hiểu từng thành phần:

```mermaid
graph TB
    subgraph HOST["AI HOST (Claude / GPT / Gemini)"]
        AI["AI Model
        Xử lý ngôn ngữ tự nhiên
        Suy luận và Ra quyết định"]
        CLIENT["MCP Client
        Quản lý kết nối
        Gửi/Nhận JSON-RPC 2.0"]
    end

    subgraph MCP_SERVER["MCP SERVER (Node.js)"]
        TRANSPORT["Transport Layer
        stdio / SSE / Streamable HTTP"]
        TOOLS["Tools Registry
        get_walls, create_wall
        get_rooms, delete_element"]
        RESOURCES["Resources
        revit://model/info
        revit://rooms/list"]
        PROMPTS["Prompts
        analyze-model
        suggest-layout"]
    end

    subgraph REVIT_PLUGIN["REVIT PLUGIN (C#)"]
        LISTENER["HTTP Listener
        localhost:8080"]
        ROUTER["Request Router
        Định tuyến tool call"]
        EVENT["External Event Handler
        Thread-safe operations"]
        API["Revit API Layer
        FilteredElementCollector
        Transaction, Document"]
    end

    subgraph REVIT["AUTODESK REVIT"]
        MODEL["BIM Model
        3D Geometry, Parameters
        Families, Levels, Views"]
    end

    AI <--> CLIENT
    CLIENT <-->|"MCP Protocol
    JSON-RPC 2.0"| TRANSPORT
    TRANSPORT <--> TOOLS
    TRANSPORT <--> RESOURCES
    TRANSPORT <--> PROMPTS
    TOOLS <-->|"HTTP REST
    localhost:8080"| LISTENER
    LISTENER --> ROUTER
    ROUTER --> EVENT
    ROUTER --> API
    EVENT <--> MODEL
    API <--> MODEL

    style HOST fill:#e8f4fd,stroke:#1976d2,stroke-width:2px
    style MCP_SERVER fill:#fff3e0,stroke:#f57c00,stroke-width:2px
    style REVIT_PLUGIN fill:#e8f5e9,stroke:#388e3c,stroke-width:2px
    style REVIT fill:#fce4ec,stroke:#c62828,stroke-width:2px
```

### Giải thích luồng dữ liệu

1. **Người dùng** gửi prompt bằng ngôn ngữ tự nhiên (ví dụ: "Liệt kê tất cả tường trong model")
2. **AI Model** phân tích prompt, quyết định gọi tool `get_walls`
3. **MCP Client** gửi JSON-RPC request đến MCP Server qua chuẩn MCP Protocol
4. **MCP Server** nhận request, gọi HTTP đến Revit Plugin tại `localhost:8080`
5. **Revit Plugin** thực thi Revit API trên main thread thông qua ExternalEvent
6. **Kết quả** được trả ngược lại: Revit → Plugin → MCP Server → AI → Người dùng

> **Điểm mấu chốt:** MCP đóng vai trò là **lớp trung gian chuẩn hóa** (standardized middleware), giúp bất kỳ AI model nào cũng có thể giao tiếp với Revit mà không cần viết code riêng cho từng model.

***

## MCP nâng cao: Resources

Trong các bài học trước, chúng ta chủ yếu làm việc với **Tools** — cho phép AI thực hiện hành động (action). Nhưng MCP còn hỗ trợ **Resources** — cho phép AI đọc dữ liệu có cấu trúc từ server như đọc một file hoặc một API endpoint.

### Resources là gì?

Resources là cách để MCP Server **cung cấp dữ liệu** cho AI mà không cần gọi tool. AI có thể **đọc** resources giống như đọc một tài liệu tham khảo trước khi đưa ra quyết định.

| Đặc điểm | Tools                           | Resources                                  |
| -------- | ------------------------------- | ------------------------------------------ |
| Mục đích | Thực hiện hành động             | Cung cấp dữ liệu                           |
| Gọi bởi  | AI quyết định gọi               | AI hoặc User yêu cầu                       |
| Ví dụ    | `create_wall`, `delete_element` | `revit://model/info`, `revit://rooms/list` |
| Kết quả  | Side effect (thay đổi model)    | Dữ liệu chỉ đọc (read-only)                |

### Code mẫu — Đăng ký Resource trong MCP Server

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

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

// Resource 1: Thông tin model hiện tại
server.resource(
  "model-info",
  "revit://model/info",
  async (uri) => {
    // Gọi sang Revit Plugin để lấy thông tin tổng quan về model
    const response = await fetch("http://localhost:8080/api/model-info");
    const modelInfo = await response.json();

    return {
      contents: [
        {
          uri: uri.href,
          mimeType: "application/json",
          text: JSON.stringify(modelInfo, null, 2),
          // Ví dụ kết quả:
          // {
          //   "projectName": "Chung cư Tân Bình - Block A",
          //   "author": "Nguyễn Văn Kỹ Sư",
          //   "discipline": "Architecture",
          //   "revitVersion": "2024",
          //   "totalElements": 4287,
          //   "levels": ["Tầng hầm", "Tầng trệt", "Tầng 1", "Tầng 2", "Tầng mái"]
          // }
        },
      ],
    };
  }
);

// Resource 2: Danh sách phòng theo tầng (có tham số động)
server.resource(
  "rooms-by-level",
  new ResourceTemplate("revit://rooms/{levelName}", { list: undefined }),
  async (uri, { levelName }) => {
    const response = await fetch(
      `http://localhost:8080/api/rooms?level=${encodeURIComponent(String(levelName))}`
    );
    const rooms = await response.json();

    return {
      contents: [
        {
          uri: uri.href,
          mimeType: "application/json",
          text: JSON.stringify(rooms, null, 2),
        },
      ],
    };
  }
);

// Resource 3: Thông số dự án (Project Parameters)
server.resource(
  "project-parameters",
  "revit://project/parameters",
  async (uri) => {
    const response = await fetch(
      "http://localhost:8080/api/project-parameters"
    );
    const params = await response.json();

    return {
      contents: [
        {
          uri: uri.href,
          mimeType: "application/json",
          text: JSON.stringify(params, null, 2),
        },
      ],
    };
  }
);

// Resource 4: Danh sách tầng (Levels)
server.resource(
  "levels-list",
  "revit://levels/all",
  async (uri) => {
    const response = await fetch("http://localhost:8080/api/levels");
    const levels = await response.json();

    return {
      contents: [
        {
          uri: uri.href,
          mimeType: "application/json",
          text: JSON.stringify(levels, null, 2),
        },
      ],
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);
```

### Khi nào dùng Resources thay vì Tools?

* Dùng **Resources** khi dữ liệu là **tĩnh** hoặc **chỉ đọc**: thông tin dự án, danh sách tầng, cấu hình hệ thống
* Dùng **Tools** khi cần **thay đổi** model hoặc thực hiện **hành động**: tạo tường, xóa element, cập nhật tham số
* Resources giúp AI có **ngữ cảnh** (context) tốt hơn trước khi quyết định gọi tool nào

***

## MCP nâng cao: Prompts

**Prompts** trong MCP là các **mẫu prompt được định nghĩa sẵn** (prompt templates) mà MCP Server cung cấp cho AI. Điều này giúp chuẩn hóa cách AI tương tác với hệ thống và tái sử dụng các workflow phổ biến.

### Tại sao cần Prompts trong MCP?

* **Chuẩn hóa** cách đặt câu hỏi cho AI về BIM data
* **Tái sử dụng** các workflow phổ biến (kiểm tra lỗi model, phân tích layout)
* **Hướng dẫn AI** thực hiện đúng quy trình phức tạp nhiều bước
* **Chia sẻ** best practices trong team mà không cần viết lại prompt

### Code mẫu — Đăng ký Prompt trong MCP Server

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

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

// Prompt 1: Phân tích tổng quan model Revit
server.prompt(
  "analyze-model",
  "Phân tích tổng quan model Revit hiện tại và đưa ra nhận xét chuyên môn",
  {},
  async () => {
    return {
      messages: [
        {
          role: "user",
          content: {
            type: "text",
            text: `Bạn là một chuyên gia BIM với 10 năm kinh nghiệm. Hãy phân tích model Revit hiện tại theo quy trình sau:

**Bước 1 — Thu thập dữ liệu:**
- Gọi tool "get_walls" để lấy danh sách tường
- Gọi tool "get_rooms" để lấy danh sách phòng
- Gọi tool "get_levels" để lấy danh sách tầng
- Đọc resource "revit://model/info" để lấy thông tin tổng quan

**Bước 2 — Phân tích:**
- Thống kê số lượng từng loại element (tường, phòng, cột, dầm, sàn)
- Đánh giá độ phức tạp của model (đơn giản / trung bình / phức tạp)
- Tính diện tích tổng theo từng tầng

**Bước 3 — Kiểm tra lỗi:**
- Tìm phòng có diện tích = 0 (phòng không hợp lệ)
- Kiểm tra element không gắn với tầng nào
- Phát hiện tường trùng lặp (duplicate)

**Bước 4 — Báo cáo:**
Trình bày kết quả theo định dạng có cấu trúc, gồm:
1. Tóm tắt tổng quan (executive summary)
2. Thống kê chi tiết theo tầng
3. Danh sách lỗi phát hiện (nếu có)
4. Đề xuất cải thiện`,
          },
        },
      ],
    };
  }
);

// Prompt 2: Kiểm tra lỗi model với tham số mức độ
server.prompt(
  "check-model-errors",
  "Kiểm tra và báo cáo lỗi trong model Revit theo mức độ nghiêm trọng",
  {
    severity: z
      .enum(["all", "critical", "warning", "info"])
      .describe("Mức độ lỗi cần kiểm tra: all / critical / warning / info"),
    autoFix: z
      .boolean()
      .optional()
      .describe("Tự động sửa lỗi nếu có thể (mặc định: false)"),
  },
  async ({ severity, autoFix = false }) => {
    return {
      messages: [
        {
          role: "user",
          content: {
            type: "text",
            text: `Hãy kiểm tra model Revit hiện tại và tìm các lỗi ở mức "${severity}".
${autoFix ? "\nNếu lỗi có thể tự động sửa, hãy thực hiện sau khi xác nhận với người dùng." : ""}

**Các loại lỗi cần kiểm tra:**

CRITICAL (Nghiêm trọng):
- Phòng có diện tích = 0 (Room Bounding không đúng)
- Element bị trùng lặp hoàn toàn (same geometry, same level)
- Tường có chiều dài = 0 (degenerate geometry)

WARNING (Cảnh báo):
- Tường không kết nối đúng cách (gap nhỏ hoặc không join)
- Element nằm ngoài phạm vi model
- Level không có element nào gắn vào

INFO (Thông tin):
- Phòng chưa được đặt tên
- Tham số bắt buộc chưa được điền
- Family chưa được tải đầy đủ

**Với mỗi lỗi phát hiện, hãy cung cấp:**
1. Mô tả lỗi rõ ràng
2. Element ID và vị trí (Level, tọa độ xấp xỉ)
3. Hướng dẫn cách khắc phục thủ công
4. Lệnh tự động sửa (nếu có thể)`,
          },
        },
      ],
    };
  }
);

// Prompt 3: Đề xuất bố trí mặt bằng cho một tầng
server.prompt(
  "suggest-layout",
  "Đề xuất bố trí mặt bằng tối ưu cho một tầng dựa trên loại công trình",
  {
    levelName: z.string().describe("Tên tầng cần bố trí (ví dụ: Tầng 1)"),
    buildingType: z
      .enum(["residential", "office", "hospital", "school", "retail"])
      .describe("Loại công trình"),
    totalArea: z
      .number()
      .optional()
      .describe("Diện tích sàn tổng (m²) — nếu biết trước"),
  },
  async ({ levelName, buildingType, totalArea }) => {
    const areaContext = totalArea
      ? `Diện tích sàn: khoảng ${totalArea}m².`
      : "Hãy đọc thông tin tầng từ model để xác định diện tích.";

    return {
      messages: [
        {
          role: "user",
          content: {
            type: "text",
            text: `Hãy phân tích tầng "${levelName}" và đề xuất bố trí mặt bằng cho công trình loại "${buildingType}".
${areaContext}

**Quy trình thực hiện:**

Bước 1 — Đọc thông tin tầng hiện tại:
- Gọi tool "get_walls" lọc theo tầng "${levelName}"
- Gọi tool "get_rooms" lọc theo tầng "${levelName}"
- Xác định kích thước tổng thể, vị trí cửa ra vào, lõi thang máy

Bước 2 — Lập phương án bố trí:
- Dựa vào tiêu chuẩn thiết kế cho "${buildingType}"
- Đề xuất cách chia phòng hợp lý
- Tính toán tọa độ cho các bức tường mới

Bước 3 — Xác nhận trước khi tạo:
- Trình bày phương án chi tiết
- Hỏi người dùng xác nhận TRƯỚC KHI tạo bất kỳ element nào
- Sau khi được xác nhận, gọi tool "create_wall" để tạo từng bức tường

**Lưu ý quan trọng:**
- Đảm bảo tuân thủ quy chuẩn QCVN về diện tích tối thiểu
- Giữ nguyên tường chịu lực hiện có
- Đề xuất vị trí cửa/sổ hợp lý`,
          },
        },
      ],
    };
  }
);
```

### Cách AI sử dụng Prompts

Khi người dùng yêu cầu, AI sẽ:

1. Liệt kê các prompts có sẵn từ MCP Server (`prompts/list`)
2. Chọn prompt phù hợp (ví dụ: `analyze-model`)
3. MCP Server trả về nội dung prompt đã định nghĩa
4. AI thực hiện theo hướng dẫn trong prompt, gọi các tools cần thiết theo đúng quy trình

***

## MCP nâng cao: Sampling

**Sampling** là tính năng cho phép **MCP Server yêu cầu AI sinh nội dung** (request the AI to generate text). Đây là luồng **ngược lại** so với bình thường — thay vì AI gọi server, server gọi lại AI để tận dụng khả năng suy luận ngôn ngữ.

### Sampling hoạt động như thế nào?

```mermaid
sequenceDiagram
    participant User as Người dùng
    participant AI as AI Model
    participant MCP as MCP Server
    participant Revit as Revit Plugin

    User->>AI: "Phân tích và tối ưu model BIM"
    AI->>MCP: Gọi tool "smart_optimize"
    MCP->>Revit: Lấy toàn bộ dữ liệu model
    Revit-->>MCP: Trả về dữ liệu BIM (JSON phức tạp)

    Note over MCP: Dữ liệu quá phức tạp<br/>để xử lý bằng rule-based code

    MCP->>AI: Sampling Request: "Phân tích dữ liệu này<br/>và đề xuất các thay đổi cần thiết"
    AI-->>MCP: Sampling Response: "Nên xóa 5 tường trùng lặp,<br/>sửa 3 phòng có lỗi, ..."

    MCP->>Revit: Thực hiện các thay đổi được đề xuất
    Revit-->>MCP: Kết quả thực thi
    MCP-->>AI: Kết quả cuối cùng
    AI-->>User: "Đã tối ưu model: xóa 5 tường trùng lặp,<br/>sửa 3 phòng không hợp lệ"
```

### Code mẫu — Sử dụng Sampling trong MCP Server

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

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

// Tool sử dụng Sampling để phân tích và tối ưu model
server.tool(
  "smart_optimize",
  "Phân tích thông minh và tối ưu model Revit bằng AI — tự động xác định và xử lý vấn đề",
  {
    optimizeType: z
      .enum(["cleanup", "performance", "naming", "standards"])
      .describe(
        "Loại tối ưu hóa: cleanup=xóa rác, performance=hiệu năng, naming=đặt tên, standards=tiêu chuẩn"
      ),
    dryRun: z
      .boolean()
      .optional()
      .describe("Chỉ phân tích không thực hiện (mặc định: true)"),
  },
  async ({ optimizeType, dryRun = true }, { sendRequest }) => {
    // Bước 1: Lấy dữ liệu toàn bộ model từ Revit
    const modelResponse = await fetch(
      "http://localhost:8080/api/full-model-snapshot"
    );
    const modelData = await modelResponse.json();

    // Bước 2: Dùng Sampling để nhờ AI phân tích dữ liệu phức tạp
    // (vì dữ liệu BIM quá phức tạp để viết rule-based code)
    const samplingResult = await sendRequest(
      {
        method: "sampling/createMessage",
        params: {
          messages: [
            {
              role: "user",
              content: {
                type: "text",
                text: `Bạn là chuyên gia BIM. Phân tích dữ liệu model Revit sau và đề xuất các thay đổi cho mục tiêu "${optimizeType}".

DỮ LIỆU MODEL:
${JSON.stringify(modelData, null, 2)}

YÊU CẦU:
Trả về kết quả dạng JSON hợp lệ với cấu trúc sau:
{
  "analysis": "Nhận xét tổng quan về model",
  "issues_found": 5,
  "actions": [
    {
      "type": "delete",
      "elementId": 12345,
      "reason": "Tường trùng lặp với element 12344",
      "risk": "low"
    },
    {
      "type": "modify",
      "elementId": 12346,
      "parameter": "ROOM_NAME",
      "newValue": "Phòng khách",
      "reason": "Phòng chưa được đặt tên",
      "risk": "low"
    }
  ],
  "skipped_actions": [
    {
      "elementId": 12347,
      "reason": "Cần xem xét thủ công trước khi xóa",
      "risk": "high"
    }
  ],
  "summary": "Tóm tắt những gì cần làm"
}`,
              },
            },
          ],
          maxTokens: 4000,
          temperature: 0,
        },
      }
    );

    // Bước 3: Parse kết quả phân tích từ AI
    const analysisText =
      samplingResult.content[0].type === "text"
        ? samplingResult.content[0].text
        : "";

    let analysisData: {
      analysis: string;
      issues_found: number;
      actions: Array<{
        type: string;
        elementId: number;
        reason: string;
        risk: string;
        parameter?: string;
        newValue?: string;
      }>;
      skipped_actions: Array<{ elementId: number; reason: string; risk: string }>;
      summary: string;
    };

    try {
      // Tách JSON ra khỏi text (AI có thể thêm giải thích xung quanh)
      const jsonMatch = analysisText.match(/\{[\s\S]*\}/);
      analysisData = JSON.parse(jsonMatch ? jsonMatch[0] : analysisText);
    } catch {
      return {
        content: [
          {
            type: "text",
            text: `Lỗi phân tích kết quả AI:\n${analysisText}`,
          },
        ],
      };
    }

    // Bước 4: Nếu dryRun=true, chỉ báo cáo không thực hiện
    if (dryRun) {
      return {
        content: [
          {
            type: "text",
            text: `PHÂN TÍCH MODEL (Dry Run — không thực hiện thay đổi):

${analysisData.analysis}

Phát hiện ${analysisData.issues_found} vấn đề.
Có thể tự động xử lý: ${analysisData.actions.length} hành động.
Cần xem xét thủ công: ${analysisData.skipped_actions.length} mục.

Tóm tắt: ${analysisData.summary}

Để thực hiện các thay đổi, gọi lại với dryRun=false.`,
          },
        ],
      };
    }

    // Bước 5: Thực hiện các thay đổi được đề xuất (chỉ risk=low)
    const safeActions = analysisData.actions.filter((a) => a.risk === "low");
    const executeResponse = await fetch(
      "http://localhost:8080/api/batch-execute",
      {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ actions: safeActions }),
      }
    );
    const executeResult = await executeResponse.json();

    return {
      content: [
        {
          type: "text",
          text: `ĐÃ TỐI ƯU MODEL:

${analysisData.summary}

Đã thực hiện ${safeActions.length}/${analysisData.actions.length} hành động (bỏ qua ${analysisData.actions.length - safeActions.length} hành động rủi ro cao).
Bỏ qua ${analysisData.skipped_actions.length} mục cần xem xét thủ công.

Kết quả: ${JSON.stringify(executeResult, null, 2)}`,
        },
      ],
    };
  }
);
```

### So sánh bốn tính năng chính của MCP

| Tính năng     | Hướng                 | Mục đích                     | Ví dụ trong Revit                             |
| ------------- | --------------------- | ---------------------------- | --------------------------------------------- |
| **Tools**     | AI → Server           | Thực hiện hành động          | Tạo tường, xóa element, cập nhật tham số      |
| **Resources** | AI → Server (đọc)     | Đọc dữ liệu có cấu trúc      | Thông tin model, danh sách tầng, cấu hình     |
| **Prompts**   | Server → AI (mẫu)     | Cung cấp workflow template   | Phân tích model, kiểm tra lỗi, đề xuất layout |
| **Sampling**  | Server → AI (yêu cầu) | Nhờ AI suy luận trên dữ liệu | Phân tích clash phức tạp, tối ưu model        |

***

## Mở rộng sang phần mềm khác

Một trong những ưu điểm lớn nhất của MCP là khả năng **mở rộng** (extensibility). Kiến trúc mà bạn đã xây dựng cho Revit có thể áp dụng cho bất kỳ phần mềm xây dựng nào khác mà không cần học lại từ đầu.

### Hệ sinh thái MCP đa phần mềm

```mermaid
graph TB
    subgraph AI_LAYER["LỚP AI"]
        AI["AI Model
        Claude / GPT / Gemini
        Hiểu ngôn ngữ tự nhiên
        Suy luận đa bước"]
        MCP_CLIENT["MCP Client
        Quản lý kết nối đồng thời
        tới nhiều MCP Server"]
    end

    subgraph MCP_LAYER["LỚP MCP SERVER"]
        MCP_REVIT["MCP Server
        Revit
        (Port 8080)"]
        MCP_NAVIS["MCP Server
        Navisworks
        (Port 8081)"]
        MCP_TEKLA["MCP Server
        Tekla Structures
        (Port 8082)"]
        MCP_ACAD["MCP Server
        AutoCAD
        (Port 8083)"]
    end

    subgraph SOFTWARE_LAYER["LỚP PHẦN MỀM"]
        REVIT["Autodesk Revit
        BIM Modeling
        C# Add-in API"]
        NAVIS["Autodesk Navisworks
        Clash Detection
        COM / .NET API"]
        TEKLA["Tekla Structures
        Steel Detailing
        .NET Open API"]
        ACAD["AutoCAD
        2D Drafting
        COM / ObjectARX"]
    end

    AI <--> MCP_CLIENT
    MCP_CLIENT <-->|"MCP Protocol"| MCP_REVIT
    MCP_CLIENT <-->|"MCP Protocol"| MCP_NAVIS
    MCP_CLIENT <-->|"MCP Protocol"| MCP_TEKLA
    MCP_CLIENT <-->|"MCP Protocol"| MCP_ACAD

    MCP_REVIT <-->|"HTTP REST"| REVIT
    MCP_NAVIS <-->|"HTTP REST"| NAVIS
    MCP_TEKLA <-->|"HTTP REST"| TEKLA
    MCP_ACAD <-->|"HTTP REST"| ACAD

    style AI_LAYER fill:#e3f2fd,stroke:#1565c0,stroke-width:2px
    style MCP_LAYER fill:#fff8e1,stroke:#f9a825,stroke-width:2px
    style SOFTWARE_LAYER fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px
```

### Navisworks MCP — Phân tích xung đột

Navisworks là phần mềm **xem xét model 3D** và **phát hiện xung đột** (clash detection). Kết nối AI với Navisworks cho phép tự động hóa quy trình kiểm tra phức tạp:

```typescript
// Ví dụ: MCP Tool cho Navisworks Clash Detection
server.tool(
  "analyze_clashes",
  "Phân tích kết quả clash detection trong Navisworks và phân loại theo mức độ",
  {
    testName: z.string().describe("Tên clash test (ví dụ: HVAC vs Structure)"),
    minSeverity: z
      .enum(["low", "medium", "high", "critical"])
      .describe("Chỉ trả về clash từ mức độ này trở lên"),
    discipline: z
      .enum(["MEP", "Structure", "Architecture", "All"])
      .optional()
      .describe("Chỉ lọc theo discipline cụ thể"),
  },
  async ({ testName, minSeverity, discipline = "All" }) => {
    const response = await fetch(
      `http://localhost:8081/api/clashes?test=${encodeURIComponent(testName)}&severity=${minSeverity}&discipline=${discipline}`
    );
    const clashes = await response.json();

    // Tự động phân nhóm clash theo khả năng xử lý
    const grouped = {
      autoResolvable: clashes.filter(
        (c: { autoFix: boolean }) => c.autoFix === true
      ),
      needsReview: clashes.filter(
        (c: { autoFix: boolean; severity: string }) =>
          !c.autoFix && c.severity !== "critical"
      ),
      critical: clashes.filter(
        (c: { severity: string }) => c.severity === "critical"
      ),
    };

    return {
      content: [
        {
          type: "text",
          text: `Phát hiện ${clashes.length} xung đột trong test "${testName}":

- Có thể tự động xử lý: ${grouped.autoResolvable.length}
- Cần xem xét thủ công: ${grouped.needsReview.length}
- Nghiêm trọng (cần kỹ sư quyết định): ${grouped.critical.length}

Chi tiết:
${JSON.stringify(grouped, null, 2)}`,
        },
      ],
    };
  }
);
```

### Tekla Structures MCP — Thiết kế kết cấu

Tekla Structures là phần mềm **thiết kế kết cấu thép và bê tông**. Kết nối AI cho phép:

* AI tạo tự động các chi tiết thép (rebar detailing) theo tiêu chuẩn TCVN
* Phân tích kết cấu và đề xuất kích thước tiết diện tối ưu
* Tự động tạo bản vẽ shop drawing
* Kiểm tra tiêu chuẩn thiết kế (TCVN, Eurocode, AISC)

### AutoCAD MCP — Bản vẽ 2D

AutoCAD là phần mềm **vẽ 2D** phổ biến nhất. Kết nối AI cho phép:

* AI đọc và phân tích bản vẽ 2D, trích xuất thông tin có cấu trúc
* Tự động tạo bản vẽ từ mô tả bằng lời
* Chuyển đổi bản vẽ 2D thành dữ liệu có cấu trúc để đưa vào Revit
* So sánh và kiểm tra sự khác biệt giữa các phiên bản bản vẽ

### Workflow liên kết đa phần mềm

Sức mạnh thực sự xuất hiện khi AI có thể điều phối **workflow xuyên suốt** giữa nhiều phần mềm trong một lần gọi:

```mermaid
graph LR
    A["Revit
    Thiết kế BIM"] -->|"Export IFC"| B["Navisworks
    Clash Detection"]
    B -->|"Báo cáo clash"| C["AI Phân tích
    Đề xuất giải pháp"]
    C -->|"Cập nhật model"| A
    A -->|"Export Steel"| D["Tekla
    Chi tiết kết cấu"]
    A -->|"Export 2D"| E["AutoCAD
    Bản vẽ thi công"]
    C -->|"Review tự động"| D
    C -->|"Review tự động"| E

    style A fill:#e3f2fd,stroke:#1565c0
    style B fill:#fff3e0,stroke:#e65100
    style C fill:#f3e5f5,stroke:#7b1fa2
    style D fill:#e8f5e9,stroke:#2e7d32
    style E fill:#fce4ec,stroke:#c62828
```

**Ví dụ prompt thực tế với đa phần mềm:**

```
Người dùng: "Hãy kiểm tra model Revit hiện tại, phát hiện tất cả xung đột
             giữa hệ thống HVAC và kết cấu thép, sau đó cập nhật model
             để khắc phục các xung đột nghiêm trọng."

AI sẽ tự động:
  1. Gọi Revit MCP: export model sang định dạng Navisworks
  2. Gọi Navisworks MCP: chạy clash test "HVAC vs Structure"
  3. Dùng Sampling: phân loại 47 clash tìm được
  4. Báo cáo: 12 xung đột nghiêm trọng, 35 xung đột nhỏ
  5. Hỏi người dùng xác nhận trước khi sửa
  6. Gọi Revit MCP: di chuyển ống HVAC để tránh kết cấu
  7. Báo cáo kết quả: "Đã sửa 10/12 xung đột nghiêm trọng"
```

***

## Ý tưởng dự án thực tế

Sau khi hoàn thành khóa học, bạn có thể áp dụng kiến thức đã học vào các dự án thực tế sau. Mỗi ý tưởng đều có thể bắt đầu ngay với kiến thức bạn đang có:

### 1. BIM Quality Checker — Kiểm tra chất lượng model tự động

Xây dựng tool AI tự động kiểm tra chất lượng model BIM theo tiêu chuẩn của công ty:

* Kiểm tra naming convention của các element (theo quy tắc đặt tên)
* Phát hiện element bị thiếu thông số bắt buộc (missing required parameters)
* Kiểm tra sự nhất quán giữa các tầng (level consistency)
* Tạo báo cáo chất lượng tự động dạng PDF/Excel
* Tích hợp vào quy trình BIM Execution Plan (BEP)

### 2. AI-Powered Quantity Takeoff — Bóc tách khối lượng thông minh

AI tự động bóc tách khối lượng từ model Revit và tạo bảng dự toán:

* Đọc tất cả element trong model theo danh mục
* Phân loại theo hạng mục (tường, sàn, trần, cửa, cửa sổ, MEP)
* Tính toán khối lượng (diện tích, thể tích, chiều dài) với đơn vị đúng
* Tra cứu đơn giá theo CSDL định mức nhà nước
* Xuất báo cáo Excel/PDF theo mẫu chuẩn dự toán

### 3. Smart Design Assistant — Trợ lý thiết kế thông minh

Trợ lý thiết kế hiểu ngôn ngữ tự nhiên và thực hiện tự động:

* Người dùng mô tả yêu cầu bằng lời ("Cần một căn hộ 2 phòng ngủ, 70m², ban công hướng đông")
* AI tự động tạo mặt bằng, đặt tường, cửa theo tiêu chuẩn
* AI đề xuất bố trí nội thất hợp lý
* Người dùng review và chỉnh sửa bằng giọng nói hoặc văn bản
* Tích hợp kiểm tra pháp lý (QCVN về chiều rộng hành lang, diện tích tối thiểu)

### 4. Construction Document Generator — Tạo hồ sơ thiết kế tự động

Tự động tạo hồ sơ thiết kế từ model BIM:

* AI đọc model, tạo thuyết minh thiết kế kiến trúc
* Tự động tạo bảng kê vật liệu hoàn thiện
* Tạo bảng thống kê cửa/cửa sổ
* Xuất các bản vẽ cần thiết (mặt bằng, mặt đứng, mặt cắt)
* Tạo hồ sơ xin phép xây dựng theo đúng biểu mẫu

***

## Lộ trình phát triển tương lai

```mermaid
graph TB
    subgraph CURRENT["HIỆN TẠI — Đã học trong khóa học"]
        T1["MCP Tools cơ bản
        get_walls, create_wall
        get_rooms, delete_element"]
        T2["Revit Plugin (C#)
        HTTP Listener
        External Event Handler"]
        T3["MCP Server (Node.js)
        Tool Registry
        HTTP forwarding"]
        T4["AI Integration
        Claude Code / GPT
        Prompt → Action → Result"]
    end

    subgraph NEXT["TIẾP THEO — Tự học thêm"]
        N1["MCP Resources
        & Prompts templates"]
        N2["MCP Sampling
        AI-powered analysis"]
        N3["Multi-tool Orchestration
        Complex workflows"]
        N4["Error Handling
        Logging & Monitoring"]
    end

    subgraph ADVANCED["NÂNG CAO — Dự án thực tế"]
        A1["Multi-software MCP
        Revit + Navisworks
        + Tekla + AutoCAD"]
        A2["Cloud Deployment
        MCP Server trên
        Azure / AWS"]
        A3["Custom AI Fine-tuning
        Model hiểu thuật ngữ
        BIM chuyên sâu"]
        A4["Production Plugin
        Đóng gói chuyên nghiệp
        Phân phối thương mại"]
    end

    T1 --> N1
    T2 --> N3
    T3 --> N2
    T4 --> N4

    N1 --> A1
    N2 --> A3
    N3 --> A2
    N4 --> A4

    style CURRENT fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px
    style NEXT fill:#fff3e0,stroke:#ef6c00,stroke-width:2px
    style ADVANCED fill:#e3f2fd,stroke:#1565c0,stroke-width:2px
```

***

## Câu hỏi tự suy nghĩ

Hãy tự trả lời các câu hỏi sau để kiểm tra và củng cố kiến thức. Click vào từng câu để xem đáp án gợi ý.

### Câu 1: Kiến trúc hệ thống

<details>

<summary><strong>Tại sao chúng ta cần MCP Server (Node.js) làm trung gian, thay vì để AI giao tiếp trực tiếp với Revit Plugin?</strong></summary>

**Trả lời:**

Có nhiều lý do quan trọng:

1. **Chuẩn hóa giao thức**: MCP là giao thức chuẩn mà nhiều AI model hỗ trợ. Nếu không có MCP, bạn phải viết code kết nối riêng cho từng AI (Claude, GPT, Gemini...), mỗi lần thay đổi AI là phải viết lại.
2. **Tách biệt quan tâm** (Separation of Concerns): MCP Server xử lý giao thức AI, Revit Plugin xử lý Revit API. Mỗi thành phần có một nhiệm vụ rõ ràng, dễ bảo trì và kiểm thử riêng.
3. **Bảo mật**: MCP Server có thể kiểm soát quyền truy cập, giới hạn các tool mà AI được phép gọi, thêm authentication và rate limiting.
4. **Linh hoạt**: Có thể thay đổi AI model hoặc thay đổi Revit plugin mà không ảnh hưởng đến phần còn lại của hệ thống.
5. **Mở rộng**: Một MCP Server có thể kết nối với nhiều phần mềm khác nhau (Navisworks, Tekla) — không thể làm điều này nếu giao tiếp trực tiếp.

</details>

### Câu 2: Tools vs Resources

<details>

<summary><strong>Cho ví dụ cụ thể: khi nào bạn nên dùng Resource thay vì Tool để cung cấp dữ liệu từ Revit cho AI?</strong></summary>

**Trả lời:**

**Dùng Resource khi:**

* Dữ liệu ít thay đổi và mang tính tham khảo: `revit://project/info` (tên dự án, địa chỉ, chủ đầu tư — không thay đổi trong phiên làm việc)
* Dữ liệu cấu hình: `revit://levels/list` (danh sách các tầng — ít khi thay đổi)
* Dữ liệu làm ngữ cảnh cho AI trước khi thực hiện tác vụ: AI cần biết có những tầng nào trước khi tạo tường

**Dùng Tool khi:**

* Cần dữ liệu thời gian thực và có thể thay đổi: `get_walls` (số lượng tường thay đổi khi người dùng tạo/xóa)
* Cần thực hiện hành động: `create_wall`, `delete_element`
* Cần tham số đầu vào phức tạp: `search_elements(category, level, parameter_filter)`
* Kết quả phụ thuộc vào trạng thái hiện tại của model

**Nguyên tắc chung:** Nếu dữ liệu chỉ cần đọc một lần để lấy ngữ cảnh và ít thay đổi → Resource. Nếu cần tương tác hoặc dữ liệu thay đổi thường xuyên → Tool.

</details>

### Câu 3: Sampling

<details>

<summary><strong>Sampling trong MCP cho phép MCP Server "gọi ngược" lại AI. Hãy mô tả một tình huống thực tế trong BIM mà tính năng này hữu ích nhất.</strong></summary>

**Trả lời:**

**Tình huống: Tự động phân loại và xử lý clash detection**

1. Người dùng yêu cầu: "Phân tích và khắc phục clash trong model"
2. AI gọi tool `auto_resolve_clashes` trên MCP Server
3. MCP Server lấy dữ liệu 847 clash từ Navisworks — quá nhiều để xử lý bằng code thông thường (mỗi clash có description khác nhau, cần đọc hiểu ngữ cảnh)
4. MCP Server dùng **Sampling** để gửi 847 clash này cho AI và yêu cầu: *"Phân loại các clash này thành: (1) có thể tự động khắc phục, (2) cần kỹ sư MEP quyết định, (3) cần kỹ sư kết cấu quyết định, (4) không nghiêm trọng — bỏ qua"*
5. AI trả về kết quả phân loại dựa trên mô tả của từng clash
6. MCP Server tự động khắc phục nhóm 1, tạo task assignment cho nhóm 2 và 3, bỏ qua nhóm 4
7. Trả kết quả cuối cùng cho người dùng

**Điểm mấu chốt:** Sampling cho phép MCP Server "mượn" khả năng đọc hiểu ngôn ngữ tự nhiên của AI để xử lý dữ liệu phức tạp mà không cần viết logic rule-based phức tạp trong code server.

</details>

### Câu 4: Mở rộng hệ thống

<details>

<summary><strong>Nếu bạn muốn thêm Tekla Structures vào hệ sinh thái MCP hiện tại, bạn cần làm những bước gì?</strong></summary>

**Trả lời:**

1. **Nghiên cứu Tekla Open API**: Tìm hiểu cách tương tác với Tekla bằng .NET (C#). Tekla Open API cũng là .NET, tương tự Revit API nhưng có namespace và object model khác.
2. **Viết Tekla Plugin (.NET)**:
   * Tạo HTTP Listener trong Tekla (tương tự Revit Plugin)
   * Triển khai các tool: `get_beams`, `get_columns`, `create_rebar`, `get_connections`
   * Xử lý thread-safe với Tekla API (cũng single-threaded như Revit)
   * Chọn cổng khác, ví dụ `localhost:8082`
3. **Tạo MCP Server mới hoặc mở rộng server hiện tại**:
   * Cách A: Tạo file `tekla-mcp-server` riêng (dễ bảo trì, chạy độc lập)
   * Cách B: Thêm tool mới vào MCP Server hiện tại với prefix `tekla_` (ví dụ: `tekla_get_beams`)
   * Cấu hình kết nối đến Tekla Plugin tại `localhost:8082`
4. **Cấu hình MCP Client**:
   * Thêm MCP server mới vào `.mcp.json` hoặc `settings.json`
   * Hoặc gộp chung vào một MCP server xử lý nhiều phần mềm
5. **Test end-to-end**: Gửi prompt yêu cầu AI tương tác với cả Revit và Tekla

**Lưu ý:** Kiến trúc MCP đã được thiết kế để mở rộng. Bạn chỉ cần lặp lại các bước đã học trong khóa học này, nhưng thay Revit API bằng Tekla Open API. Kiến thức về MCP Server (Node.js) và cách đăng ký tool hoàn toàn tái sử dụng được.

</details>

### Câu 5: Thiết kế Tool hiệu quả

<details>

<summary><strong>Khi thiết kế một MCP Tool mới (ví dụ: tool tính toán kết cấu), bạn nên thiết kế input/output như thế nào để AI sử dụng hiệu quả nhất?</strong></summary>

**Trả lời:**

**Nguyên tắc thiết kế Tool hiệu quả:**

1. **Input rõ ràng và có mô tả chi tiết:**

   ```typescript
   {
     beamId: z.number().describe(
       "ID của dầm cần tính toán (lấy từ kết quả get_beams)"
     ),
     loadType: z.enum(["dead", "live", "wind", "seismic"])
       .describe("Loại tải trọng cần kiểm tra"),
     loadValue: z.number().describe(
       "Giá trị tải trọng (kN/m) — chỉ dùng với dead/live load"
     ),
     safetyFactor: z.number().optional().describe(
       "Hệ số an toàn (mặc định: 1.5 theo TCVN)"
     )
   }
   ```
2. **Output có cấu trúc và đầy đủ đơn vị:**

   ```json
   {
     "beamId": 12345,
     "beamName": "B300x600 - Tầng 2",
     "maxMoment": 150.5,
     "maxShear": 75.2,
     "deflection": 12.3,
     "deflectionLimit": 16.7,
     "status": "PASS",
     "utilizationRatio": 0.78,
     "units": { "moment": "kN.m", "shear": "kN", "deflection": "mm" },
     "standard": "TCVN 5574:2018"
   }
   ```
3. **Tên tool và description phải tự giải thích**: AI dựa vào description để quyết định gọi tool nào. Mô tả càng rõ, AI chọn càng chính xác.
4. **Xử lý lỗi rõ ràng**: Trả về message lỗi cụ thể thay vì throw exception. AI cần hiểu lỗi gì xảy ra để thông báo người dùng hoặc thử lại.
5. **Kích thước vừa phải**: Mỗi tool làm một việc. Thay vì một tool làm tất cả, chia thành nhiều tool nhỏ để AI tổ hợp linh hoạt.

</details>

***

## Cộng đồng và đóng góp

### Tham gia đóng góp

Dự án **DeepBIM Revit MCP Plugin** là mã nguồn mở (open-source). Bạn có thể đóng góp bằng nhiều cách:

* **Báo lỗi** (Bug Report): Mở issue trên GitHub khi gặp lỗi
* **Đề xuất tính năng** (Feature Request): Chia sẻ ý tưởng tool mới
* **Đóng góp code** (Pull Request): Viết thêm tool, sửa lỗi, cải thiện tài liệu
* **Chia sẻ kinh nghiệm**: Viết blog, làm video, chia sẻ với cộng đồng BIM Việt Nam

**Repository chính:** <https://github.com/nguyenngocdue/deepbim-revit-mcp-plugin>

### Các bước đóng góp code

```bash
# Bước 1: Fork repository trên GitHub

# Bước 2: Clone về máy
git clone https://github.com/<your-username>/deepbim-revit-mcp-plugin.git
cd deepbim-revit-mcp-plugin

# Bước 3: Tạo branch mới theo quy ước đặt tên
git checkout -b feature/add-get-floors-tool
# hoặc
git checkout -b fix/http-listener-crash-on-timeout

# Bước 4: Viết code, chạy test
npm test                  # Test MCP Server
dotnet test               # Test Revit Plugin

# Bước 5: Commit với message rõ ràng
git add .
git commit -m "feat: add get_floors tool to retrieve floor data by level"

# Bước 6: Push và tạo Pull Request trên GitHub
git push origin feature/add-get-floors-tool
```

### Tài nguyên học tập và cộng đồng

| Tài nguyên                      | Liên kết                                                                                                       |
| ------------------------------- | -------------------------------------------------------------------------------------------------------------- |
| MCP Specification               | [spec.modelcontextprotocol.io](https://spec.modelcontextprotocol.io)                                           |
| MCP TypeScript SDK              | [github.com/modelcontextprotocol/typescript-sdk](https://github.com/modelcontextprotocol/typescript-sdk)       |
| MCP Inspector (Debug Tool)      | [github.com/modelcontextprotocol/inspector](https://github.com/modelcontextprotocol/inspector)                 |
| Revit API Documentation         | [revitapidocs.com](https://www.revitapidocs.com)                                                               |
| The Building Coder (Blog)       | [thebuildingcoder.typepad.com](https://thebuildingcoder.typepad.com)                                           |
| DeepBIM Plugin (Dự án khóa học) | [github.com/nguyenngocdue/deepbim-revit-mcp-plugin](https://github.com/nguyenngocdue/deepbim-revit-mcp-plugin) |
| MCP Server Examples             | [github.com/modelcontextprotocol/servers](https://github.com/modelcontextprotocol/servers)                     |
| Claude Code Documentation       | [docs.anthropic.com/claude-code](https://docs.anthropic.com/en/docs/claude-code)                               |

***

## Lời kết truyền cảm hứng

### Những gì bạn đã đạt được

Sau 10 bài học, bạn đã:

1. **Hiểu kiến trúc** kết nối AI với phần mềm xây dựng qua giao thức MCP chuẩn hóa
2. **Viết được Revit Plugin (C#)** với HTTP Listener, External Event Handler, và Revit API
3. **Dựng được MCP Server (Node.js)** với Tools, Resources, Prompts và Sampling
4. **Kết nối thành công** AI (Claude/GPT) với Revit qua MCP — end-to-end
5. **Mở rộng hệ thống** với thêm tool và kiến trúc đa phần mềm
6. **Đóng gói plugin** sẵn sàng phân phối và sử dụng trong dự án thực tế

### Tầm nhìn lớn hơn

Khóa học này không chỉ là về Revit hay MCP. Đây là về **tư duy kết nối** — khả năng nhìn thấy cách các hệ thống có thể làm việc cùng nhau thông qua các giao thức chuẩn.

Trong tương lai, AI sẽ ngày càng tích hợp sâu hơn vào quy trình thiết kế và xây dựng. Những người hiểu cách **kết nối** AI với các công cụ chuyên ngành sẽ là những người tạo ra giá trị lớn nhất cho ngành.

Bạn không chỉ học một công nghệ — bạn đang học **cách tư duy về tương lai của ngành xây dựng**.

***

> *"AI không thay thế kỹ sư — nhưng kỹ sư biết dùng AI sẽ thay thế kỹ sư không biết dùng AI."*

***

Cảm ơn bạn đã đồng hành cùng khóa học **Revit API x MCP x AI — Từ Zero đến Plugin hoàn chỉnh**.

Hành trình học tập không dừng lại ở đây — đây chỉ là điểm bắt đầu. Hãy tiếp tục xây dựng, thử nghiệm, và chia sẻ với cộng đồng. Mỗi dòng code bạn viết, mỗi tool bạn tạo, đều là một bước tiến đến tương lai của ngành xây dựng thông minh.

**Chúc bạn thành công trên hành trình kết nối AI với thế giới xây dựng!**

***

## Tài liệu tham khảo

### Tài liệu chính thức

* [Model Context Protocol — Specification](https://spec.modelcontextprotocol.io) — Đặc tả đầy đủ của giao thức MCP
* [MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk) — Thư viện chính thức để xây dựng MCP Server bằng TypeScript
* [Revit API Developer Guide](https://www.revitapidocs.com) — Tài liệu tham khảo Revit API
* [Anthropic Documentation](https://docs.anthropic.com) — Hướng dẫn sử dụng Claude và Claude Code

### Dự án tham khảo

* [DeepBIM Revit MCP Plugin](https://github.com/nguyenngocdue/deepbim-revit-mcp-plugin) — Dự án chính của khóa học này
* [Revit MCP Server](https://github.com/nguyenngocdue/revit-mcp-server) — Tham chiếu thực tế cho phần tạo tool và triển khai MCP Server
* [MCP Servers Collection](https://github.com/modelcontextprotocol/servers) — Tập hợp các MCP server mẫu từ cộng đồng
* [Awesome MCP Servers](https://github.com/punkpeye/awesome-mcp-servers) — Danh sách các MCP server cộng đồng

### Học thêm về Revit API

* [Revit API Forum](https://forums.autodesk.com/t5/revit-api-forum/bd-p/160) — Diễn đàn chính thức của Autodesk
* [The Building Coder](https://thebuildingcoder.typepad.com) — Blog kinh điển về Revit API bởi Jeremy Tammik
* [Revit API Docs](https://www.revitapidocs.com) — Tra cứu class, method, property

### Học thêm về MCP

* [MCP Introduction](https://modelcontextprotocol.io/introduction) — Giới thiệu tổng quan về MCP
* [Building MCP Servers](https://modelcontextprotocol.io/quickstart/server) — Hướng dẫn xây dựng MCP Server
* [MCP Inspector](https://github.com/modelcontextprotocol/inspector) — Công cụ debug MCP Server

***

> **Quay lại bài đầu tiên:** [Bài 1: Giới thiệu tổng quan →](/revit-mcp-ai/phan-1-nen-tang/bai-1.md)
>
> Có câu hỏi hoặc góp ý? Tạo issue trên [GitHub repository](https://github.com/nguyenngocdue/deepbim-revit-mcp-plugin/issues).
>
> Toàn bộ mã nguồn và tài liệu được lưu tại [github.com/nguyenngocdue/deepbim-revit-mcp-plugin](https://github.com/nguyenngocdue/deepbim-revit-mcp-plugin).


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://deepbim.gitbook.io/revit-mcp-ai/phan-4-nang-cao-and-hoan-thien/bai-10.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.