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 类型转换为运行时函数的转换库。

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

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

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

在AMD Ryzen 9 7940HS、Rog Flow x13上测量

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

Jensen Huang Graph 及其倡导：https://youtu.be/R0Erk6J8o70

凭借其 TypeScript 编译功能，typia正在挑战 Agentic AI 框架格局。

这个新框架名为@agentica，它专注于LLM 函数调用，所有操作都通过函数调用完成。函数调用模式源自typia.llm.application<Class, Model>()函数。

这是一个使用企业级购物中心后端的 Swagger/OpenAPI 文档编写的购物中心聊天机器人的演示，该文档包含 289 个 API 函数。正如您在下方视频中看到的那样，一切运行顺畅。更令人称奇的是，这个购物聊天机器人仅使用一个小型模型（gpt-4o-mini8b 个参数）就实现了 Agentic AI 的功能。

这是由编译器技术开启的全新 Agentic AI 时代typia。只需列出要调用的函数，即可实现由黄仁勋开创的 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 函数调用

https://platform.openai.com/docs/guides/function-calling

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

typia并@agentica专注于并精通这个概念——使用函数调用来实现 Agentic AI。单从 LLM 函数调用的定义来看，它是一个非常优雅的概念，你可能会想，为什么它没有得到更广泛的应用。难道仅仅通过列出任何给定时间所需的函数，就无法实现 Agentic AI 吗？

在本文档中，我们将探讨为什么函数调用尚未被广泛采用，并了解如何typia使其@agentica适用于通用应用程序。

3.概念

3.1. 传统人工智能开发

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

然而，这种代理工作流方法在可扩展性和灵活性方面存在严重缺陷。当代理的功能需要扩展时，AI 开发人员必须创建越来越复杂的代理工作流，并包含越来越多的图节点。

此外，随着代理图节点数量的增加，成功率会下降。这是因为成功率会根据节点数的笛卡尔积而下降。例如，如果每个节点的成功率为 80%，并且有五个连续节点，则代理工作流的总体成功率仅为 32.77% (0.8 ⁵ )。

为了缓解这种笛卡尔积灾难，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. 验证反馈

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）。

这 80 亿个参数意味着 Agentic AI 甚至可以在个人笔记本电脑级别实现。只需一张 8GB VRAM 显卡即可实现 Agentic AI。这种由编译器驱动的开发支持的验证反馈策略，正是其typia能够成功挑战 Agentic AI 领域的原因。

4.3. 内部工作流程

中的内部代理工作流程@agentica。

Agentica 的内部代理编排也很简单。它只有三个代理工作流：“选择器”、“调用器”和“描述器”。

选择器代理旨在通过分析对话上下文来选择或取消候选功能。如果它找不到合适的功能，则默认以普通聊天机器人的身份进行对话。

调用者代理会尝试通过组合参数来调用候选函数。如果上下文不够充分，它会请求用户提供调用所需的其余属性。选择器和调用者代理之间会形成一个循环，直到没有剩余的候选函数。

描述代理只是描述函数调用的结果。

如您所见，Agentica 的工作流程并不复杂，甚至可能比许多其他流程更简单。实现 Agentic AI 的关键并非在于设计复杂的代理工作流程。关键在于拥有一个能够安全高效地批量生成 LLM 函数调用模式的系统。

函数调用就是一切。让我们拥抱函数调用吧。

5. 结论

typia是一个转换器库，最初是作为运行时验证器。如今，它凭借其编译器技能成功实现了 Agentic AI。

Agentic AI 源于 LLM 函数调用，typia是其最佳解决方案。类型安全且便捷的编译级 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");