资深工程师必知的7个JavaScript AI库（让AI开发不再复杂）

┌─────────────────────────────────────────┐
│      AI 功能的复杂度演变                 │
├─────────────────────────────────────────┤
│                                         │
│  10年前：需要 ML 专家团队               │
│  ├─ 数学、算法理解                      │
│  ├─ 模型设计、训练                      │
│  ├─ 基础设施（GPU、显存）               │
│  └─ 性能优化、部署                      │
│                                         │
│  今年：一个 JS 开发者足够                │
│  ├─ 调用 API 或库函数                   │
│  ├─ 选择合适的模型参数                  │
│  ├─ 在浏览器或 Node.js 中运行           │
│  └─ 根据业务需求做提示词优化            │
│                                         │
└─────────────────────────────────────────┘

                   你的 AI 需求
                        │
            ┌───────────┼───────────┐
            │           │           │
    需要快速上线   需要本地推理   需要复杂流程
            │           │           │
         路线1        路线2        路线3
            │           │           │
   OpenAI SDK │ Transformers.js   LangChain
        +     │   TensorFlow.js   + 向量库
     其他API  │   ONNX/Brain.js   + 存储

import { ChatOpenAI } from"langchain/chat_models/openai";
import { VectorStoreIndex } from"langchain/indexes";
import { PineconeStore } from"langchain/vectorstores/pinecone";
import { PromptTemplate } from"langchain/prompts";

// 1. 初始化模型
const model = new ChatOpenAI({
temperature: 0.7,
modelName: "gpt-4",
apiKey: process.env.OPENAI_API_KEY,
});

// 2. 连接向量数据库（比如 Pinecone）
const vectorStore = await PineconeStore.fromExistingIndex(
new OpenAIEmbeddings(),
  { pineconeIndex: "doc-index" }
);

// 3. 创建 RAG 链
const qaPrompt = new PromptTemplate({
template: `根据以下背景信息回答问题。
  
背景：{context}

问题：{question}`,
inputVariables: ["context", "question"],
});

const chain = new RetrievalQAChain.fromLLMAndRetriever(
  model,
  vectorStore.asRetriever(),
  { prompt: qaPrompt }
);

// 4. 问问题
const answer = await chain.call({
query: "我们的产品支持哪些支付方式？"
});

import { pipeline } from"@xenova/transformers";

// 创建分类器（第一次会下载模型，约 100MB）
const classifier = await pipeline(
"sentiment-analysis",
"Xenova/bert-base-multilingual-uncased-sentiment"// 支持中文！
);

// 分析中文评论
const result = await classifier("这个功能太棒了！");
// 输出：[{ label: 'POSITIVE', score: 0.998 }]

// 批量分析
const reviews = [
"产品质量不错，值得推荐",
"客服态度很差，体验很不好",
"一般般，没什么特色"
];

for (const review of reviews) {
const [result] = await classifier(review);
console.log(`"${review}" → ${result.label}`);
}

import * as tf from"@tensorflow/tfjs";

// 训练数据：[房间数, 面积] -> 价格（单位：万元）
const trainingData = {
inputs: [[2, 50], [3, 70], [4, 100], [5, 120]],
outputs: [[50], [80], [150], [180]]
};

// 创建模型：简单的神经网络
const model = tf.sequential({
layers: [
    // 输入层：2 个特征
    tf.layers.dense({ units: 32, activation: "relu", inputShape: [2] }),
    // 隐藏层：32 个神经元
    tf.layers.dense({ units: 16, activation: "relu" }),
    // 输出层：1 个输出（价格）
    tf.layers.dense({ units: 1 })
  ]
});

// 编译模型
model.compile({
optimizer: tf.train.adam(0.01),
loss: "meanSquaredError"
});

// 准备数据
const xs = tf.tensor2d(trainingData.inputs);
const ys = tf.tensor2d(trainingData.outputs);

// 训练
await model.fit(xs, ys, {
epochs: 100,
verbose: 1,
batchSize: 2
});

// 预测：5 房间，150 平米的房子要多少钱？
const prediction = model.predict(tf.tensor2d([[5, 150]]));
prediction.print(); // 输出约 [180] ~ [200] 万元

// 清理张量（释放内存）
xs.dispose();
ys.dispose();
prediction.dispose();

const brain = require("brain.js");

// 创建神经网络
const net = new brain.NeuralNetwork({
hiddenLayers: [8] // 1 个隐藏层，8 个神经元
});

// 训练数据：[登录尝试次数, IP地址是否异常] -> [是否欺诈]
net.train([
  { input: { attempts: 1, ipAnomaly: 0 }, output: { fraud: 0 } },
  { input: { attempts: 1, ipAnomaly: 1 }, output: { fraud: 0.3 } },
  { input: { attempts: 10, ipAnomaly: 0 }, output: { fraud: 0.7 } },
  { input: { attempts: 15, ipAnomaly: 1 }, output: { fraud: 1 } }
], {
iterations: 1000,
errorThresh: 0.005
});

// 预测：8 次尝试，IP 异常 -> 欺诈概率？
const result = net.run({ attempts: 8, ipAnomaly: 1 });
console.log(`欺诈概率：${(result.fraud * 100).toFixed(0)}%`);
// 输出：欺诈概率：85%

const natural = require("natural");

// 分词
const tokenizer = new natural.WordTokenizer();
const text = "React 是一个 JavaScript 库，用于构建用户界面。React 还支持 TypeScript。";
const tokens = tokenizer.tokenize(text);
console.log(tokens);
// 输出：["React", "是", "一个", "JavaScript", "库", ...]

// 词干提取（English 和中文支持都有）
const stemmer = natural.PorterStemmer;
console.log(stemmer.stem("running")); // "run"
console.log(stemmer.stem("developer")); // "develop"

// TF-IDF：计算词语的重要性
const tfidf = new natural.TfIdf();
tfidf.addDocument("React Vue Angular 前端框架对比");
tfidf.addDocument("Vue 是渐进式框架，易学易用");
tfidf.addDocument("Angular 是企业级框架，功能完整");

// "Vue" 在第 2 和 3 个文档中都出现了，但在第 1 个没有
// TF-IDF 会给 "Vue" 一个较低的分数（因为它出现在多个文档）
// 而 "React" 只在第 1 个出现，分数会更高
tfidf.tfidfs("React", (i, score) => {
console.log(`文档 ${i}: React 的 TF-IDF = ${score.toFixed(3)}`);
});

Python 环境：
  PyTorch / TensorFlow / scikit-learn
           ↓
      导出为 ONNX 格式
           ↓
JavaScript 环境：
  ONNX Runtime Web
           ↓
      在浏览器或 Node.js 推理

import * as ort from"onnxruntime-web";

// 1. 加载 ONNX 模型
const session = await ort.InferenceSession.create("./mobilenet.onnx");

// 2. 准备输入（图像转张量）
const canvas = document.getElementById("imageCanvas");
const ctx = canvas.getContext("2d");
const imageData = ctx.getImageData(0, 0, 224, 224);
const pixels = newFloat32Array(224 * 224 * 3);

// 归一化像素值到 [-1, 1]
for (let i = 0; i < imageData.data.length; i += 4) {
  pixels[i / 4] = (imageData.data[i] - 127.5) / 127.5;
// R, G, B 通道
}

// 3. 创建输入张量
const input = new ort.Tensor("float32", pixels, [1, 3, 224, 224]);

// 4. 运行推理
const feeds = { input };
const results = await session.run(feeds);

// 5. 获取输出（概率分布）
const output = results.output.data;
const topClass = Array.from(output).indexOf(Math.max(...output));
console.log(`识别的对象：${classNames[topClass]}`);

import OpenAI from"openai";

const openai = new OpenAI({
apiKey: process.env.OPENAI_API_KEY
});

// 单次对话
const response = await openai.chat.completions.create({
model: "gpt-4-turbo",
messages: [
    {
      role: "system",
      content: "你是一个友善的电商客服，用中文回答问题"
    },
    {
      role: "user",
      content: "我买的东西还没收到，什么时候能到？"
    }
  ],
temperature: 0.7,
max_tokens: 500
});

console.log(response.choices[0].message.content);

// 流式对话（实时返回结果）
const stream = await openai.chat.completions.create({
model: "gpt-4-turbo",
messages: [
    { role: "user", content: "给我讲个笑话" }
  ],
stream: true
});

forawait (const chunk of stream) {
  process.stdout.write(
    chunk.choices[0]?.delta?.content || ""
  );
}

// ❌ 烂提示词
"总结这个文本"

// ✅ 好提示词
`请用中文、100字以内总结以下文本，突出关键业务价值：

[文本内容]

总结应该包括：
1. 主要内容
2. 关键数字/指标
3. 行动建议`

// 关键：记录所有 AI 交互
logger.info({
  prompt: userInput,
  response: aiOutput,
  tokens: usage.total_tokens,
  latency: endTime - startTime,
  timestamp: new Date()
});

假设：
- 月活 10 万用户
- 每用户月均 5 次 AI 交互
- 每次调用平均 500 tokens

成本 = 50 万次 × 500 tokens × $0.00001 ≈ $2500/月

这在早期可能是 showstopper，必须考虑。

你的需求是什么？
│
├─ "我需要快速原型"
│  └─ → 用 OpenAI SDK（最快）
│
├─ "我需要本地运行，不上传数据"
│  ├─ 是小模型任务（分类、摘要）
│  │  └─ → Transformers.js
│  │
│  └─ 我想自己训练模型
│     └─ → TensorFlow.js 或 Brain.js
│
├─ "我需要连接多个工具（向量库、工具调用等）"
│  └─ → LangChain.js
│
├─ "我有 Python 训练的模型，想在 JS 中用"
│  └─ → ONNX Runtime Web
│
└─ "我只需要文本处理，不需要深度学习"
   └─ → Natural