X-hub

./read "AI-Native Architectu..."

AI-Native Architecture：构建智能化应用的完全指南

ai-native_architecture：构建智能化应用.md2025-10-15
./meta --show-details
Published
2025年10月15日
Reading
24 min
Words
23,019
Status
PUBLISHED
--ai原生--rag--向量数据库--llm--ai agent

AI-Native Architecture：构建智能化应用的完全指南

目录

  1. 什么是 AI 原生架构
  2. 核心技术栈
  3. 应用场景
  4. 开发实战 Demo
  5. 主流框架对比
  6. 最佳实践
  7. 挑战与解决方案

1. 什么是 AI 原生架构

1.1 概念理解

AI-Native Architecture 是将 AI（特别是大语言模型 LLM）作为一等公民集成到系统架构中的设计理念，而非简单地调用 API。

传统 AI 集成 vs AI 原生：

传统方式（AI 作为附加功能）：
应用 → [业务逻辑] → 偶尔调用 AI API → 返回结果

AI 原生方式（AI 作为核心）：
用户输入 → AI 理解意图 → 编排工作流 → 调用工具/数据库 → AI 生成响应

1.2 核心特征

特征传统应用AI 原生应用
交互方式固定 UI 表单、按钮自然语言对话
业务逻辑代码硬编码规则AI 动态推理决策
数据检索SQL 精确查询向量语义搜索
工作流程预定义流程图AI Agent 自主编排
个性化基于规则的推荐上下文理解的智能推荐

1.3 架构演进

第一代：规则引擎时代

if (user.age > 18 && user.income > 50000) {
  return "高价值客户";
}
// 问题：规则爆炸、难以维护

第二代：机器学习时代

model = train(features, labels)
prediction = model.predict(user_features)
# 问题：需要大量标注数据、模型更新慢

第三代：AI 原生时代

const response = await ai.chat({
  messages: [
    { role: "system", content: "你是客户分析专家" },
    { role: "user", content: `分析客户：${JSON.stringify(userData)}` }
  ]
});
// 优势：零样本学习、灵活适应、自然交互

2. 核心技术栈

2.1 四大核心技术

1. 大语言模型（LLM）

┌─────────────────────────────────────┐
│     LLM（大脑）                      │
│  - GPT-4, Claude, Gemini            │
│  - 理解、推理、生成                  │
└─────────────────────────────────────┘

2. 向量数据库（Vector Database）

┌─────────────────────────────────────┐
│   向量数据库（长期记忆）             │
│  - 存储文档/知识的向量表示           │
│  - 语义搜索                          │
└─────────────────────────────────────┘

3. RAG（检索增强生成）

用户问题 → 向量化 → 检索相关文档 → 注入 Prompt → LLM 生成回答

优势：
✅ 减少幻觉（基于真实数据）
✅ 动态知识更新（无需重新训练）
✅ 可追溯来源（引用原始文档）

4. AI Agent（智能代理）

用户任务 → Agent 规划 → 调用工具 → 执行步骤 → 返回结果

能力：
✅ 自主决策（选择使用哪些工具）
✅ 多步推理（分解复杂任务）
✅ 错误修复（失败后重试）

2.2 技术栈全景

┌──────────────────────────────────────────────────┐
│                  用户界面                         │
│         (Chat UI, Voice, API)                     │
├──────────────────────────────────────────────────┤
│              LLM 编排层                           │
│    LangChain / LlamaIndex / Vercel AI SDK        │
├──────────────────────────────────────────────────┤
│            AI 能力层                              │
│  ┌──────────┬──────────┬──────────┬──────────┐  │
│  │ LLM 调用 │ 向量检索 │ Agent    │ Prompt   │  │
│  │ (OpenAI) │ (RAG)    │ (ReAct)  │ Template │  │
│  └──────────┴──────────┴──────────┴──────────┘  │
├──────────────────────────────────────────────────┤
│            数据存储层                             │
│  ┌──────────┬──────────┬──────────────────────┐ │
│  │向量数据库│关系数据库│    缓存 / 队列        │ │
│  │(Pinecone)│(Postgres)│  (Redis / Queue)     │ │
│  └──────────┴──────────┴──────────────────────┘ │
└──────────────────────────────────────────────────┘

2.3 向量数据库详解

传统数据库 vs 向量数据库

对比维度传统数据库 (SQL)向量数据库
查询方式精确匹配（WHERE id = 123）相似度搜索（语义相近）
数据类型结构化数据（表格）向量（文本、图片、音频的嵌入）
查询示例"查找 ID=5 的用户""查找与'苹果手机'语义相似的产品"
应用场景CRUD 操作、事务处理语义搜索、推荐系统、RAG

向量化示例：

// 文本 → 向量
const text = "苹果公司推出新款 iPhone";
const vector = await embeddings.create(text);

// vector = [0.123, -0.456, 0.789, ..., 0.234]  // 1536 维向量

// 语义搜索
const results = await vectorDB.search({
  vector: vector,
  topK: 5  // 返回最相似的 5 个结果
});

// 结果可能包含："iPhone 15 Pro 发布"、"苹果新品发布会"等

3. 应用场景

3.1 最适合的场景

✅ 智能客服 / 知识库问答

用户："如何退货？"
→ RAG 检索公司政策文档
→ AI 生成个性化回答

✅ 代码助手 / 技术文档助手

开发者："如何使用 React Hooks？"
→ 检索官方文档 + 最佳实践
→ 生成代码示例 + 详细解释

✅ 企业知识管理

员工："公司的报销流程是什么？"
→ 检索内部文档、邮件、Wiki
→ 整合多源信息生成回答

✅ 个性化推荐

用户："推荐适合健身的蓝牙耳机"
→ 理解需求（防水、低延迟）
→ 检索产品数据库
→ 生成推荐理由

✅ 数据分析助手

分析师："上季度销售数据的异常点在哪？"
→ Agent 编写 SQL 查询
→ 执行数据分析
→ 生成可视化报告

3.2 不太适合的场景

❌ 实时性要求极高

  • 高频交易、游戏服务器（LLM 延迟 500ms-2s）

❌ 确定性要求 100%

  • 医疗诊断、金融审批（AI 有概率性）

❌ 简单的 CRUD 操作

  • 基础增删改查（过度设计）

4. 开发实战 Demo

4.1 项目：构建智能文档问答系统（RAG）

我们将构建一个完整的 RAG 系统，能够：

  • 上传 Markdown 文档
  • 自动向量化并存储
  • 自然语言问答

4.2 技术栈

mkdir ai-native-rag && cd ai-native-rag
npm init -y
npm install @langchain/openai @langchain/community langchain openai dotenv express

4.3 核心代码实现

1. 环境配置（.env）

OPENAI_API_KEY=your_openai_api_key_here

2. 向量存储（vectorStore.js）

// vectorStore.js - 简化的内存向量存储
const { OpenAIEmbeddings } = require('@langchain/openai');

class SimpleVectorStore {
  constructor() {
    this.embeddings = new OpenAIEmbeddings({
      openAIApiKey: process.env.OPENAI_API_KEY,
    });
    this.documents = []; // { id, text, vector, metadata }
  }

  // 添加文档
  async addDocuments(docs) {
    for (const doc of docs) {
      // 生成向量
      const vector = await this.embeddings.embedQuery(doc.text);

      this.documents.push({
        id: this.generateId(),
        text: doc.text,
        vector,
        metadata: doc.metadata || {}
      });

      console.log(`[VectorStore] Added document: ${doc.text.substring(0, 50)}...`);
    }
  }

  // 相似度搜索
  async similaritySearch(query, k = 3) {
    // 查询文本向量化
    const queryVector = await this.embeddings.embedQuery(query);

    // 计算余弦相似度
    const results = this.documents.map(doc => ({
      ...doc,
      similarity: this.cosineSimilarity(queryVector, doc.vector)
    }));

    // 排序并返回 top-k
    return results
      .sort((a, b) => b.similarity - a.similarity)
      .slice(0, k);
  }

  // 余弦相似度计算
  cosineSimilarity(vecA, vecB) {
    const dotProduct = vecA.reduce((sum, val, i) => sum + val * vecB[i], 0);
    const magnitudeA = Math.sqrt(vecA.reduce((sum, val) => sum + val * val, 0));
    const magnitudeB = Math.sqrt(vecB.reduce((sum, val) => sum + val * val, 0));
    return dotProduct / (magnitudeA * magnitudeB);
  }

  generateId() {
    return `doc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  getStats() {
    return {
      totalDocuments: this.documents.length,
      avgVectorDim: this.documents[0]?.vector.length || 0
    };
  }
}

module.exports = SimpleVectorStore;

3. RAG 系统（ragSystem.js）

// ragSystem.js
const { ChatOpenAI } = require('@langchain/openai');
const SimpleVectorStore = require('./vectorStore');

class RAGSystem {
  constructor() {
    this.vectorStore = new SimpleVectorStore();
    this.llm = new ChatOpenAI({
      openAIApiKey: process.env.OPENAI_API_KEY,
      modelName: 'gpt-4o-mini',
      temperature: 0.7,
    });
  }

  // 文档分块（Chunking）
  chunkDocument(text, chunkSize = 500, overlap = 100) {
    const chunks = [];
    let start = 0;

    while (start < text.length) {
      const end = start + chunkSize;
      const chunk = text.slice(start, end);
      chunks.push(chunk);
      start = end - overlap; // 重叠部分避免语义断裂
    }

    return chunks;
  }

  // 索引文档
  async indexDocument(text, metadata = {}) {
    console.log(`[RAG] Indexing document (${text.length} chars)...`);

    // 1. 分块
    const chunks = this.chunkDocument(text);
    console.log(`[RAG] Split into ${chunks.length} chunks`);

    // 2. 存储到向量数据库
    const docs = chunks.map(chunk => ({
      text: chunk,
      metadata: { ...metadata, chunkLength: chunk.length }
    }));

    await this.vectorStore.addDocuments(docs);
    console.log(`[RAG] ✅ Indexing complete`);
  }

  // RAG 问答
  async query(question) {
    console.log(`\n[RAG] Query: "${question}"`);

    // 1. 检索相关文档
    const relevantDocs = await this.vectorStore.similaritySearch(question, 3);

    console.log(`[RAG] Found ${relevantDocs.length} relevant chunks:`);
    relevantDocs.forEach((doc, i) => {
      console.log(`  ${i + 1}. [Similarity: ${doc.similarity.toFixed(3)}] ${doc.text.substring(0, 80)}...`);
    });

    // 2. 构建 Prompt
    const context = relevantDocs.map(doc => doc.text).join('\n\n---\n\n');

    const prompt = `你是一个智能助手，请基于以下上下文回答用户问题。如果上下文中没有相关信息，请明确告知用户。

上下文信息：
${context}

用户问题：${question}

回答：`;

    // 3. 调用 LLM 生成答案
    console.log(`[RAG] Generating answer...`);
    const response = await this.llm.invoke(prompt);

    return {
      answer: response.content,
      sources: relevantDocs.map(doc => ({
        text: doc.text.substring(0, 100) + '...',
        similarity: doc.similarity
      }))
    };
  }
}

module.exports = RAGSystem;

4. HTTP 服务器（server.js）

// server.js
require('dotenv').config();
const express = require('express');
const RAGSystem = require('./ragSystem');

const app = express();
app.use(express.json());

const rag = new RAGSystem();

// 示例文档（也可以从文件读取）
const sampleDocs = `
# Next.js 开发指南

## 什么是 Next.js
Next.js 是一个基于 React 的全栈框架，由 Vercel 开发。它提供了服务端渲染（SSR）、静态站点生成（SSG）、API 路由等功能。

## 核心特性
1. **App Router**：Next.js 13 引入的新路由系统，基于 React Server Components。
2. **Server Actions**：允许在服务端直接处理表单提交和数据变更。
3. **Image Optimization**：自动优化图片，支持 WebP 格式。
4. **Incremental Static Regeneration (ISR)**：静态页面可以按需重新生成。

## 如何开始
\`\`\`bash
npx create-next-app@latest my-app
cd my-app
npm run dev
\`\`\`

访问 http://localhost:3000 即可看到默认页面。

## 数据获取
在 App Router 中，可以直接在组件中使用 async/await 获取数据：

\`\`\`jsx
async function Page() {
  const data = await fetch('https://api.example.com/data');
  const json = await data.json();
  return <div>{json.title}</div>;
}
\`\`\`

## 路由
文件系统路由：
- app/page.js → /
- app/about/page.js → /about
- app/blog/[slug]/page.js → /blog/:slug

## 部署
最简单的部署方式是使用 Vercel：
\`\`\`bash
npm install -g vercel
vercel
\`\`\`
`;

// 启动时索引文档
(async () => {
  console.log('📚 Indexing sample documents...');
  await rag.indexDocument(sampleDocs, { source: 'nextjs-guide' });
  console.log('✅ Indexing complete\n');
})();

// API: 上传文档
app.post('/index', async (req, res) => {
  try {
    const { text, metadata } = req.body;

    if (!text) {
      return res.status(400).json({ error: 'Text is required' });
    }

    await rag.indexDocument(text, metadata);

    res.json({
      success: true,
      message: 'Document indexed successfully',
      stats: rag.vectorStore.getStats()
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// API: 问答
app.post('/query', async (req, res) => {
  try {
    const { question } = req.body;

    if (!question) {
      return res.status(400).json({ error: 'Question is required' });
    }

    const result = await rag.query(question);

    res.json({
      success: true,
      ...result
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// API: 获取统计信息
app.get('/stats', (req, res) => {
  res.json({
    success: true,
    stats: rag.vectorStore.getStats()
  });
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`\n🚀 RAG System running on http://localhost:${PORT}`);
  console.log(`\n📚 API Endpoints:`);
  console.log(`  POST   /index       - 索引新文档`);
  console.log(`  POST   /query       - 问答查询`);
  console.log(`  GET    /stats       - 系统统计\n`);
});

5. 测试客户端（test.js）

// test.js
const http = require('http');

function request(method, path, body = null) {
  return new Promise((resolve, reject) => {
    const options = {
      hostname: 'localhost',
      port: 3000,
      path,
      method,
      headers: { 'Content-Type': 'application/json' }
    };

    const req = http.request(options, (res) => {
      let data = '';
      res.on('data', chunk => data += chunk);
      res.on('end', () => resolve(JSON.parse(data)));
    });

    req.on('error', reject);
    if (body) req.write(JSON.stringify(body));
    req.end();
  });
}

async function runTests() {
  console.log('🧪 Testing RAG System\n');

  // 1. 查询统计
  console.log('1️⃣ 系统统计：');
  const stats = await request('GET', '/stats');
  console.log(JSON.stringify(stats, null, 2));

  await sleep(1000);

  // 2. 问答测试
  const questions = [
    'Next.js 是什么？',
    '如何开始一个 Next.js 项目？',
    'Next.js 的核心特性有哪些？',
    '如何在 Next.js 中获取数据？',
    'Python 和 JavaScript 的区别是什么？' // 不相关问题
  ];

  for (const question of questions) {
    console.log(`\n2️⃣ 问题: ${question}`);
    const result = await request('POST', '/query', { question });

    console.log(`\n✅ 回答:\n${result.answer}\n`);
    console.log(`📄 来源:`);
    result.sources.forEach((src, i) => {
      console.log(`  ${i + 1}. [相似度: ${src.similarity.toFixed(3)}] ${src.text}`);
    });

    await sleep(2000);
  }

  console.log('\n✅ 测试完成！');
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

setTimeout(runTests, 2000);

4.4 运行 Demo

1. 配置环境变量

echo "OPENAI_API_KEY=sk-your-key-here" > .env

2. 启动服务器

node server.js

3. 运行测试（新终端）

node test.js

4. 手动测试

# 问答查询
curl -X POST http://localhost:3000/query \
  -H "Content-Type: application/json" \
  -d '{"question": "如何部署 Next.js 应用？"}'

# 索引新文档
curl -X POST http://localhost:3000/index \
  -H "Content-Type: application/json" \
  -d '{"text": "你的文档内容...", "metadata": {"source": "custom"}}'

4.5 预期输出

{
  "success": true,
  "answer": "部署 Next.js 应用最简单的方式是使用 Vercel。步骤如下：\n\n1. 安装 Vercel CLI：`npm install -g vercel`\n2. 在项目目录运行：`vercel`\n3. 按照提示完成部署\n\nVercel 会自动检测 Next.js 项目并进行优化部署。",
  "sources": [
    {
      "text": "## 部署\n最简单的部署方式是使用 Vercel：\n```bash\nnpm install -g vercel\nvercel\n```...",
      "similarity": 0.892
    }
  ]
}

5. 主流框架对比

5.1 LLM 编排框架

框架语言特点适用场景Star
LangChainPython/JS生态最丰富、组件化设计复杂 AI 应用、RAG、Agent⭐ 85k+
LlamaIndexPython专注数据索引和检索企业知识库、文档问答⭐ 32k+
Vercel AI SDKTypeScript轻量、流式响应、UI 集成Next.js/React 应用⭐ 8k+
ChatDevPythonMulti-Agent 协作自动化软件开发⭐ 24k+
AutoGPTPython自主 AI Agent自动化任务执行⭐ 163k+

5.2 向量数据库

数据库部署方式特点适用场景
Pinecone云托管完全托管、易用、快速生产环境、快速上线
Weaviate自托管/云开源、GraphQL API复杂查询、混合搜索
Milvus自托管高性能、可扩展、开源大规模部署、私有化
Qdrant自托管/云Rust 实现、高性能高并发场景
pgvectorPostgreSQL 插件SQL + 向量、易集成已有 Postgres 应用

5.3 快速上手：Vercel AI SDK

// app/api/chat/route.ts (Next.js App Router)
import { OpenAIStream, StreamingTextResponse } from 'ai';
import { Configuration, OpenAIApi } from 'openai-edge';

const config = new Configuration({
  apiKey: process.env.OPENAI_API_KEY,
});
const openai = new OpenAIApi(config);

export async function POST(req: Request) {
  const { messages } = await req.json();

  const response = await openai.createChatCompletion({
    model: 'gpt-4',
    stream: true,
    messages,
  });

  const stream = OpenAIStream(response);
  return new StreamingTextResponse(stream);
}

// app/page.tsx
'use client';
import { useChat } from 'ai/react';

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit } = useChat();

  return (
    <div>
      {messages.map(m => (
        <div key={m.id}>
          {m.role}: {m.content}
        </div>
      ))}

      <form onSubmit={handleSubmit}>
        <input value={input} onChange={handleInputChange} />
        <button type="submit">Send</button>
      </form>
    </div>
  );
}

6. 最佳实践

6.1 Prompt Engineering

❌ 不好的 Prompt

const prompt = "分析这个数据";

✅ 好的 Prompt（结构化）

const prompt = `
你是一个专业的数据分析师。

## 任务
分析以下销售数据，找出异常点和趋势。

## 数据
${JSON.stringify(salesData)}

## 输出格式
请按以下 JSON 格式返回：
{
  "trends": ["趋势1", "趋势2"],
  "anomalies": [{"date": "2024-01-01", "reason": "原因"}],
  "recommendations": ["建议1", "建议2"]
}

## 注意事项
- 仅基于提供的数据分析
- 如果数据不足，明确说明
`;

6.2 Prompt Templates（模板化）

class PromptTemplate {
  static analyzeCode(code, language) {
    return `
你是一个 ${language} 代码审查专家。

## 代码
\`\`\`${language}
${code}
\`\`\`

## 审查维度
1. 代码质量（可读性、维护性）
2. 性能问题
3. 安全漏洞
4. 最佳实践

请提供详细的审查报告。
`;
  }

  static summarizeDocument(text, maxLength = 200) {
    return `
请将以下文档总结为不超过 ${maxLength} 字的摘要。

文档内容：
${text}

摘要：
`;
  }
}

// 使用
const prompt = PromptTemplate.analyzeCode(userCode, 'javascript');
const response = await llm.invoke(prompt);

6.3 成本优化

1. 缓存策略

class LLMCache {
  constructor() {
    this.cache = new Map();
  }

  async invoke(prompt) {
    // 计算 prompt 的哈希
    const hash = this.hash(prompt);

    // 检查缓存
    if (this.cache.has(hash)) {
      console.log('[Cache] Hit!');
      return this.cache.get(hash);
    }

    // 调用 LLM
    const response = await llm.invoke(prompt);

    // 存储缓存
    this.cache.set(hash, response);

    return response;
  }

  hash(str) {
    // 简单哈希实现
    return str.split('').reduce((a, b) => {
      a = ((a << 5) - a) + b.charCodeAt(0);
      return a & a;
    }, 0).toString();
  }
}

2. 模型分层

// 简单任务用小模型，复杂任务用大模型
async function smartInvoke(task, complexity) {
  if (complexity === 'low') {
    return await gpt35.invoke(task);  // 便宜
  } else if (complexity === 'medium') {
    return await gpt4oMini.invoke(task);
  } else {
    return await gpt4.invoke(task);  // 贵但强大
  }
}

3. 流式输出

// 提升用户体验，减少等待时间
for await (const chunk of await llm.stream(prompt)) {
  process.stdout.write(chunk);  // 实时显示
}

6.4 安全与隐私

输入过滤

function sanitizeInput(userInput) {
  // 移除敏感信息
  const sanitized = userInput
    .replace(/\b\d{16}\b/g, '[CARD_NUMBER]')  // 信用卡号
    .replace(/\b\d{3}-\d{2}-\d{4}\b/g, '[SSN]'); // 社保号

  return sanitized;
}

输出验证

function validateOutput(llmOutput) {
  // 检查是否包含危险内容
  const dangerousPatterns = [
    /eval\(/,
    /exec\(/,
    /<script>/i
  ];

  for (const pattern of dangerousPatterns) {
    if (pattern.test(llmOutput)) {
      throw new Error('Unsafe output detected');
    }
  }

  return llmOutput;
}

7. 挑战与解决方案

7.1 常见挑战

挑战问题解决方案
幻觉（Hallucination）AI 生成虚假信息RAG、引用来源、用户确认
成本控制API 调用费用高缓存、小模型、流式输出
响应延迟LLM 调用慢（1-3s）流式输出、异步处理、优化 Prompt
上下文长度限制Token 限制（4k-128k）智能截断、摘要、Map-Reduce
数据隐私敏感数据发送到第三方本地模型、数据脱敏、私有部署

7.2 RAG 优化技巧

问题：检索不准确

// ❌ 简单检索
const docs = await vectorDB.search(query, 3);

// ✅ 混合检索（向量 + 关键词）
const vectorResults = await vectorDB.search(query, 5);
const keywordResults = await fullTextSearch(query, 5);
const mergedResults = mergeAndRerank(vectorResults, keywordResults);

问题：上下文过长

// ✅ Map-Reduce 策略
async function longDocumentQA(question, longDocument) {
  // 1. Map：分段总结
  const chunks = splitDocument(longDocument);
  const summaries = await Promise.all(
    chunks.map(chunk => llm.invoke(`总结：${chunk}`))
  );

  // 2. Reduce：基于总结回答
  const combinedSummary = summaries.join('\n');
  return await llm.invoke(`基于总结回答：${combinedSummary}\n\n问题：${question}`);
}

7.3 Agent 可靠性

// 带重试和验证的 Agent
class ReliableAgent {
  async execute(task, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
      try {
        const plan = await this.plan(task);
        const result = await this.executePlan(plan);

        // 验证结果
        if (await this.validate(result, task)) {
          return result;
        }

        console.log(`Attempt ${i + 1} failed validation, retrying...`);
      } catch (error) {
        console.error(`Attempt ${i + 1} failed:`, error);
      }
    }

    throw new Error('Agent failed after max retries');
  }
}

总结

核心要点

  1. AI 是核心：将 LLM 作为系统的中央处理器
  2. RAG 是基础：减少幻觉、动态知识更新
  3. 向量是关键：语义搜索代替关键词搜索
  4. Agent 是未来：自主决策、多步推理

适合你吗？

✅ 适合使用 AI 原生架构的情况：

  • 知识密集型应用
  • 需要自然语言交互
  • 个性化推荐系统
  • 内容创作辅助

❌ 暂时不适合的情况：

  • 简单的 CRUD 应用
  • 确定性要求 100%
  • 成本敏感且低价值场景

学习路径

  1. 理解概念：LLM、Embeddings、向量数据库
  2. 动手实践：完成本文 RAG Demo
  3. 深入框架：学习 LangChain 或 Vercel AI SDK
  4. 构建 Agent：尝试 ReAct、AutoGPT 模式
  5. 生产部署：监控、成本优化、安全加固

推荐资源

官方文档：

开源项目：

学习课程：

AI 原生架构不是未来，而是现在。开始构建你的智能化应用吧！🤖

navigation.log
./nav --show-adjacent-posts
PREV

Composable Architecture：构建灵活可插拔的现代应用

2025-10-15

NEXT
没有更新的文章
comments.logDiscussion Thread
./comments --show-all

讨论区

./loading comments...