typia（速度快 20,000 倍的验证器）利用其编译器技能向 Agentic AI 框架发起挑战

1. 前言

typia对 Agentic AI 及其编译器技能的挑战。

新的挑战来自于新的开源框架@agentica。

它专门用于 LLM 函数调用，并可以用它做任何事情。只需列出要调用的函数，然后您也可以制作 Agentic AI。如果您是 TypeScript 开发人员，那么您现在就是 AI 开发人员。让我们成为新时代的 AI 开发人员。

• @agentica：https://wrtnlabs.io/agentica

• typia：https ://typia.io

import { Agentica } from "@agentica/core";
import { HttpLlm } from "@samchon/openapi";
import typia from "typia";

const agent = new Agentica({
  controllers: [
    HttpLlm.application({
      model: "chatgpt",
      document: await fetch(
        "https://shopping-be.wrtn.ai/editor/swagger.json",
      ).then(r => r.json()),
    }),
    typia.llm.application<ShoppingCounselor, "chatgpt">(),
    typia.llm.application<ShoppingPolicy, "chatgpt">(),
    typia.llm.application<ShoppingSearchRag, "chatgpt">(),
  ],
});
await agent.conversate("I wanna buy MacBook Pro");

2. 概要

2.1. Transformer 库

//----
// src/checkString.ts
//----
import typia, { tags } from "typia";
export const checkString = typia.createIs<string>();

//----
// bin/checkString.js
//----
import typia from "typia";
export const checkString = (() => {
  return (input) => "string" === typeof input;
})();

typia是一个将 TypeScript 类型转换为运行时函数的转换库。

如果你调用其中一个typia函数，它将像下面这样被编译。这是 的关键概念typia，将 TypeScript 类型转换为运行时函数。通过在编译级别typia.is<T>()分析目标类型，该函数被转换为专用的类型检查器。T

此功能使开发人员能够确保其应用程序中的类型安全，利用 TypeScript 的静态类型，同时提供运行时验证。您无需定义额外的手动架构，只需使用纯 TypeScript 类型本身即可。

此外，由于验证（或序列化）逻辑是由编译器分析 TypeScript 源代码生成的，因此它比任何其他竞争库都更准确、更快。

2.2. 对代理人工智能的挑战

凭借TypeScript编译技能，typia向Agentic AI框架发起挑战。

新框架名为@agentica，它专门用于LLM 函数调用，并且用函数调用来做所有事情。函数调用模式，它来自于typia.llm.application<Class, Model>()function。

这是由企业级购物中心后端的 Swagger/OpenAPI 文档编写的购物中心聊天机器人的演示，包含 289 个 API 函数。从下面的视频中可以看到，一切运行正常。令人惊奇的是，购物聊天机器人仅通过小型模型（gpt-4o-mini，8b 个参数）就完成了 Agentic AI。

这是由编译器技能开启的 Agentic AI 新时代typia。只需列出要调用的函数，就可以实现 Jensen Huang 开创的 Agentic AI。如果你是 TypeScript 开发人员，那么你现在就是 AI 开发人员。

import { Agentica } from "@agentica/core";
import { HttpLlm } from "@samchon/openapi";
import typia from "typia";

const agent = new Agentica({
  controllers: [
    HttpLlm.application({
      model: "chatgpt",
      document: await fetch(
        "https://shopping-be.wrtn.ai/editor/swagger.json",
      ).then(r => r.json()),
    }),
    typia.llm.application<ShoppingCounselor, "chatgpt">(),
    typia.llm.application<ShoppingPolicy, "chatgpt">(),
    typia.llm.application<ShoppingSearchRag, "chatgpt">(),
  ],
});
await agent.conversate("I wanna buy MacBook Pro");

2.3. LLM 函数调用

LLM（大型语言模型）函数调用，是指AI通过分析与用户的对话上下文，选择合适的函数进行调用，并填充函数的参数。

typia并@agentica集中和专门研究了函数调用这一概念，以实现 Agentic AI。仅查看 LLM 函数调用的定义，它就是一个很酷的概念，您会想知道为什么它没有被使用。通过列出当时需要的函数，难道不能实现 Agentic AI 吗？

在本文档中，我们将了解为什么函数调用不能被普遍接受，并了解如何typia使@agentica它们再次被普遍接受。

3.概念

3.1. 传统人工智能开发

在传统的AI开发中，AI开发人员专注于由多个图节点组成的代理工作流。他们专注于专用AI代理的开发，而不是制作通用的代理。

顺便说一句，这种代理工作流程有一个关键的弱点：可扩展性和灵活性。如果扩展代理的功能，AI 开发人员必须使用越来越多的图形节点来制作更复杂的代理工作流程。

此外，代理图节点数的增加意味着成功率的降低。这是因为成功率随着节点数乘以笛卡尔积而降低。例如，如果每个节点的成功率为 80%，并且依次有五个节点，则代理工作流的成功率变为 32.77% (0.8 5 )。

为了规避笛卡尔积灾难，AI开发人员需要制作一个新的主管工作流程，作为附加组件附加到主工作流程的节点。在这种情况下，如果功能再次扩展，则需要工作流程的分形。为了避免笛卡尔积灾难，AI开发人员必须面对另一个分形灾难。

按照这样的代理工作流方式，能不能做出像代理一样的购物聊天机器人？能不能做出企业级的聊天机器人？这就是为什么世界上只有专用的聊天机器人或像玩具项目一样的聊天机器人在流传。

问题在于代理工作流本身很难创建，并且可扩展性和灵活性极低。

3.2. 文档驱动开发

每个功能均独立记录。

为了避免笛卡尔积和代理工作流分形带来的灾难，我建议采用一种新方法“文档驱动开发”。它与“领域驱动开发”方法类似，将复杂项目划分为小领域，从而使开发更容易且可扩展。唯一的区别是，在分离概念中还需要文档注释。

为每个函数单独编写文档注释，向 AI 描述每个函数的用途。信任@agentica和 LLM 函数调用，并对其承担所有其他责任。只需为每个函数单独编写文档注释，您就可以让您的代理具有可扩展性、灵活性和大规模生产性。

如果某些函数之间存在关系，请不要创建代理工作流，而只需将其作为描述注释写下来。以下是一份有良好文档记录的函数和模式列表。

• 功能

• ShoppingSaleController

• DTO 架构

• IShoppingCouponRestriction

• IShoppingCartCommodityStock

• IShoppingSaleUnitStock

export class BbsArticleService {
  /**
   * Get all articles.
   *
   * List up every articles archived in the BBS DB.
   *
   * @returns List of every articles
   */
  public index(): IBbsArticle[];

  /**
   * Create a new article.
   *
   * Writes a new article and archives it into the DB.
   *
   * @param props Properties of create function
   * @returns Newly created article
   */
  public create(props: {
    /**
     * Information of the article to create
     */
    input: IBbsArticle.ICreate;
  }): IBbsArticle;

  /**
   * Update an article.
   *
   * Updates an article with new content.
   *
   * @param props Properties of update function
   * @param input New content to update
   */
  public update(props: {
    /**
     * Target article's {@link IBbsArticle.id}.
     */
    id: string & tags.Format<"uuid">;

    /**
     * New content to update.
     */
    input: IBbsArticle.IUpdate;
  }): void;

  /**
   * Erase an article.
   *
   * Erases an article from the DB.
   *
   * @param props Properties of erase function
   */
  public erase(props: {
    /**
     * Target article's {@link IBbsArticle.id}.
     */
    id: string & tags.Format<"uuid">;
  }): void;
}

3.3. 编译器驱动开发

LLM 函数调用模式必须由编译器编写。

@agentica是一个专门用于LLM函数调用的Agentic AI框架，它所做的一切都是通过函数调用来实现的。因此，最重要的一点就是，如何安全有效地构建LLM模式。

顺便说一下，在传统的AI开发中，AI开发人员已经定义了手工的LLM函数调用模式。这是典型的重复编码，并且是危险的实体定义方法。

如果手工模式定义出现错误，人类可以凭直觉避免。然而，人工智能永远不会原谅这样的错误。无效的手工模式定义将破坏整个代理系统。

所以，如果 LLM 模式如此困难和烦人，@agentica那么框架就会变得困难和烦人。同样，如果 LLM 模式构建如此危险，@agentica那么框架也会变得危险。

import { ILlmApplication } from "@samchon/openapi";
import typia from "typia";

import { BbsArticleService } from "./BbsArticleService";

const app: ILlmApplication<"chatgpt"> = typia.llm.application<
  BbsArticleService,
  "chatgpt"
>();
console.log(app);

为了确保此类 LLM 函数模式构建的安全性和便捷性，typia支持typia.llm.application<Class, Model>()函数。它分析目标 TypeScript 类的类型，并在编译级别生成适当的 LLM 函数调用模式。

由于模式是由编译器通过源代码分析构建的，因此模式定义不可能有任何错误。不再需要手动定义模式，也不再需要重复编码。

这种编译器驱动的模式生成将带您进入新的 Agentic AI 时代。

顺便说一下，@agentica函数模式不仅可以从 TypeScript 类类型中获取，还可以从 Swagger/OpenAPI 文档中获取。那么后端开发呢？如何在后端环境中实现编译器驱动开发？

4. 原则

4.1. OpenAPI规范

OpenAPI 规范到 LLM 函数调用方案的转换。

LLM 函数调用需要基于 JSON Schema 的函数模式，但各个 LLM（大型语言模型）服务商的 JSON Schema 规范并不相同，「OpenAI GPT」和「Anthropic Claude」的 LLM 函数调用 JSON Schema 规范有所不同，Google Gemini 也与它们不同。

更可怕的是，Swagger/OpenAPI 文档还使用了与 LLM 函数调用模式不同的 JSON 模式规范，并且 Swagger/OpenAPI 各个版本之间的规范差别很大。

为了解决这个问题，@agentica我们使用@samchon/openapi。当 Swagger/OpenAPI 文档到达时，它会转换为 OpenAPI v3.1 修订规范。然后将其转换为服务供应商特定的 LLM 函数调用模式，从而绕过迁移模式。

作为参考，迁移模式是另一种中间件模式，它将 OpenAPI 操作模式转换为类似功能的模式。此外，如果你想成为一名能够制作基本库或框架的适度 AI 开发人员，最好了解每个模式的定义。

• Swagger/OpenAPI 文档

• OpenAPI v3.1 修订

• OpenAPI v3.1

• OpenAPI v3.0

• Swagger v2.0

• LLM 函数调用模式

• ILlmApplication<Model>

• ILlmFunction<Model>

• LLM DTO 模式

• IChatGptSchema: OpenAI ChatGPT

• IClaudeSchema: 人性化的克劳德

• IGeminiSchema：谷歌双子座

• ILlamaSchema: 元骆驼

• 中间层模式

• ILlmSchemaV3：基于OpenAPI v3.0规范的中间层

• ILlmSchemaV3_1：基于OpenAPI v3.1规

4.2. Validation Feedback

Components	typia	TypeBox	ajv	io-ts	zod	C.V.
Easy to use	✅	❌	❌	❌	❌	❌
Object (simple)	✔	✔	✔	✔	✔	✔
Object (hierarchical)	✔	✔	✔	✔	✔	✔
Object (recursive)	✔	❌	✔	✔	✔	✔
Object (union, implicit)	✅	❌	❌	❌	❌	❌
Object (union, explicit)	✔	✔	✔	✔	✔	❌
Object (additional tags)	✔	✔	✔	✔	✔	✔
Object (template literal types)	✔	✔	✔	❌	❌	❌
Object (dynamic properties)	✔	✔	✔	❌	❌	❌
Array (rest tuple)	✅	❌	❌	❌	❌	❌
Array (hierarchical)	✔	✔	✔	✔	✔	✔
Array (recursive)	✔	✔	✔	✔	✔	❌
Array (recursive, union)	✔	✔	❌	✔	✔	❌
Array (R+U, implicit)	✅	❌	❌	❌	❌	❌
Array (repeated)	✅	❌	❌	❌	❌	❌
Array (repeated, union)	✅	❌	❌	❌	❌	❌
Ultimate Union Type	✅	❌	❌	❌	❌	❌

C.V.方法class-validator

LLM 函数调用完美吗？不，绝对不是。

@agentica是一个专注于LLM函数调用的Agentic AI框架。如果有熟悉AI开发的人，可能会问一个问题，“LLM函数调用安全吗？在参数组合过程中不会产生幻觉？”答案是，“不，绝对不安全。LLM函数调用失败的次数太多了”。

顺便说一句，@agentica是一个专门用于函数调用的框架。如果函数调用如此危险，那意味着这@agentica也是危险的，它会破坏 的关键概念@agentica。

为了克服这种危险的函数调用，Agentica需要通过这种方式来纠正类型错误。首先，让 LLM 做出无效的参数。然后检查并将每个类型错误详细告知代理。这样代理就可以在下一次试验中纠正函数调用。这是验证反馈策略。

而对于准确详细的验证反馈，@agentica则使用typia.validate<T>()函数。由于验证逻辑是由编译器分析 TypeScript 源代码生成的，因此它的错误跟踪比任何其他的都更详细、更准确。

有了这种由编译器驱动的强大的验证反馈策略，@agentica在参数组合级别上调用 LLM 函数不会失败。实际上，之前演示的 289 个 API 函数的企业级购物聊天机器人运行的是 8b 个参数的小模型（gpt-4o-mini）。

8b 参数，意味着 Agentic AI 甚至可以在个人笔记本电脑层面实现。仅使用 8 GB VRAM 显卡即可实现 Agentic AI。这是编译器驱动开发的验证反馈策略。这就是为什么typia可以挑战 Agentic AI 的原因。

4.3. 内部工作流程

内部代理工作流程@agentica。

Agentica 内部代理的编排也比较简单，只有“选择器”、“调用器”、“描述器”三个代理的工作流程。

选择器代理被设计为通过分析对话上下文来选择或取消候选功能。如果它未能找到任何合适的功能来选择，则只作为普通聊天机器人进行对话。

调用者代理尝试通过组合参数来调用候选函数，如果上下文不够，则要求用户输入剩余的属性来调用，选择器和调用者代理之间有一个循环语句，直到候选函数为空。

最后一个描述代理仅描述函数调用的结果。

可以看出，Agentica 的工作流程从来都不复杂，甚至可能比任何其他工作流程都简单。实现 Agentic AI 的关键不在于设计复杂代理工作流程的能力。实现 Agentic AI 的关键在于拥有一个可以安全高效地批量生成 LLM 函数调用模式的系统。

函数调用就是一切。让我们进行函数调用。

5. 结论

typia是一个从运行时验证器开始的转换器库，如今已利用其编译器技能成功实现了 Agentic AI。

Agentic AI 源自于LLM函数调用，typia是LLM函数调用的最佳解决方案。类型安全且在编译级别方便的LLM函数调用模式生成，是Agentic AI开发中最重要的。

事实上，typia在支持该typia.llm.application<Class, Model>()功能后，的下载量正在急剧增加，typia原来每月有几十万人使用的 ，现在每月有数百万人使用。

typia让我们和一起参与新的 Agentic AI 时代@agentica。你们这些 TypeScript 开发人员，现在就是 AI 开发人员。

import { Agentica } from "@agentica/core";
import { HttpLlm } from "@samchon/openapi";
import typia from "typia";

const agent = new Agentica({
  controllers: [
    HttpLlm.application({
      model: "chatgpt",
      document: await fetch(
        "https://shopping-be.wrtn.ai/editor/swagger.json",
      ).then(r => r.json()),
    }),
    typia.llm.application<ShoppingCounselor, "chatgpt">(),
    typia.llm.application<ShoppingPolicy, "chatgpt">(),
    typia.llm.application<ShoppingSearchRag, "chatgpt">(),
  ],
});
await agent.conversate("I wanna buy MacBook Pro");