Preparing diagram...

interface AgentConfig {
  systemPrompt: string;           // 角色与边界
  tools: Tool[];                  // Tool / Action 列表
  memoryStrategy: MemoryConfig;   // Memory 策略
  ragDataSource?: RAGConfig;      // RAG 数据源
  decisionMode: 'ReAct' | 'PlanAndExecute';  // 决策方式
  model: ModelConfig;             // LLM 配置
}

interface Tool {
  name: string;
  description: string;
  parameters: ParameterSchema;
  execute: (params: any) => Promise<any>;
}

interface MemorySystem {
  shortTerm: {
    type: 'WindowBuffer';
    windowSize: number;  // 保留最近 N 轮对话
    messages: Message[];
  };
  longTerm: {
    type: 'Database' | 'Redis' | 'VectorStore';
    storage: StorageBackend;
    indexBy: 'userId' | 'sessionId';
  };
}

// 策略 1: 限制窗口大小
const memoryConfig = {
  windowSize: 5,  // 只保留最近 5 轮
  maxTokens: 2000  // 限制总 token 数
};

// 策略 2: 摘要化历史
const summarizeHistory = async (messages: Message[]) => {
  if (messages.length > 10) {
    const summary = await llm.summarize(messages.slice(0, -5));
    return [summary, ...messages.slice(-5)];
  }
  return messages;
};

// 策略 3: 选择性记忆
const shouldStore = (message: Message) => {
  return message.containsPreference || 
         message.containsDecision || 
         message.isImportant;
};

Preparing diagram...

// RAG 增强的 Agent
interface RAGAgent extends Agent {
  knowledgeBase: VectorStore;
  
  async answer(question: string): Promise<string> {
    // 1. 检索相关文档
    const docs = await this.knowledgeBase.search(question, topK: 3);
    
    // 2. 读取 Memory
    const memory = await this.memory.load();
    
    // 3. 构建 Prompt
    const prompt = `
      用户问题: ${question}
      
      相关资料:
      ${docs.map(d => d.content).join('\n\n')}
      
      历史对话:
      ${memory}
      
      请基于以上资料和历史对话回答问题。
    `;
    
    // 4. LLM 生成
    return await this.llm.generate(prompt);
  }
}

interface VectorStore {
  // 添加文档
  addDocuments(docs: Document[]): Promise<void>;
  
  // 相似度搜索
  similaritySearch(query: string, k: number): Promise<Document[]>;
  
  // 删除文档
  delete(ids: string[]): Promise<void>;
  
  // 更新文档
  update(id: string, doc: Document): Promise<void>;
}

interface Document {
  id: string;
  content: string;
  metadata: Record<string, any>;
  embedding?: number[];  // 向量表示
}

// 传统数据库查询
SELECT * FROM documents 
WHERE content LIKE '%苹果%';
// 只能找到包含"苹果"字样的文档

// Vector Store 查询
vectorStore.similaritySearch("苹果");
// 可以找到:
// - "iPhone 13 Pro"
// - "Mac Studio"
// - "Apple Watch"
// - "水果店"

// Embedding 过程
const text = "人工智能正在改变世界";

// 1. 文本 → 向量
const embedding = await embeddingModel.embed(text);
// embedding: [0.123, -0.456, 0.789, ..., 0.234]  // 1536 维向量

// 2. 存储到 Vector Store
await vectorStore.add({
  id: "doc1",
  content: text,
  embedding: embedding
});

// 3. 查询
const query = "AI 的影响";
const queryEmbedding = await embeddingModel.embed(query);
const results = await vectorStore.search(queryEmbedding, topK: 3);

Preparing diagram...

interface N8NAgentConfig {
  // 1. Chat Model
  model: {
    provider: 'OpenAI' | 'Anthropic' | 'Ollama';
    modelName: string;
    temperature: number;
  };
  
  // 2. Memory
  memory: {
    type: 'WindowBuffer' | 'Motorhead' | 'Redis';
    sessionId: string;  // 关键!
    windowSize?: number;
  };
  
  // 3. Tools
  tools: Array<{
    name: string;
    description: string;
    node: string;  // n8n 节点引用
  }>;
  
  // 4. System Prompt
  systemMessage: string;
}

Preparing diagram...

你是一个专业的技术顾问助手。

重要规则:
1. 你必须参考之前的对话内容来回答
2. 记住用户的偏好和背景信息
3. 如果用户之前提到过相关信息,要主动引用
4. 保持对话的连贯性和个性化

当前用户信息会在对话历史中提供。

// 数据结构
interface UserMemory {
  userId: string;
  memory: string;  // 摘要化的信息
  lastUpdated: Date;
}

// 示例
const memory: UserMemory = {
  userId: "123",
  memory: "用户偏好技术类回答,偏好简洁。是一名前端工程师,关注 React 和 TypeScript。",
  lastUpdated: new Date()
};

// Memory 更新策略
const shouldUpdateMemory = (message: Message): boolean => {
  // 检查是否包含关键信息
  const keywords = ['偏好', '喜欢', '不喜欢', '需要', '目标'];
  const containsKeyInfo = keywords.some(k => message.content.includes(k));
  
  // 检查是否是重要决策
  const isDecision = message.type === 'decision';
  
  // 检查是否是新信息
  const isNewInfo = !existingMemory.includes(message.summary);
  
  return containsKeyInfo || isDecision || isNewInfo;
};

Preparing diagram...

// 完整的 Memory Agent 实现
class MemoryAgent {
  private llm: LLM;
  private memoryStore: MemoryStore;
  
  async chat(userId: string, message: string): Promise<string> {
    // 1. 读取 Memory
    const memory = await this.memoryStore.load(userId);
    
    // 2. 构建 Prompt
    const prompt = `
      用户记忆:
      ${memory}
      
      当前对话:
      用户: ${message}
      
      请基于用户记忆回答,并在回答中体现你对用户的了解。
    `;
    
    // 3. LLM 生成
    const response = await this.llm.generate(prompt);
    
    // 4. 判断是否更新 Memory
    if (this.shouldUpdateMemory(message, response)) {
      const newInfo = await this.extractKeyInfo(message, response);
      await this.memoryStore.update(userId, newInfo);
    }
    
    return response;
  }
  
  private async extractKeyInfo(message: string, response: string): Promise<string> {
    const extractPrompt = `
      从以下对话中提取需要记住的关键信息:
      
      用户: ${message}
      助手: ${response}
      
      只提取偏好、决策、重要背景信息。用一句话概括。
    `;
    
    return await this.llm.generate(extractPrompt);
  }
}

第 1 轮:
用户: 我是一名前端工程师
Agent: 了解了,你是前端工程师。有什么我可以帮助你的吗?
[Memory 更新: "用户是前端工程师"]

第 2 轮:
用户: 我最近在学习 TypeScript
Agent: 很好!TypeScript 对前端工程师来说是很重要的技能。
[Memory 更新: "用户是前端工程师,正在学习 TypeScript"]

第 3 轮:
用户: 有什么好的学习资源推荐吗?
Agent: 基于你刚才提到的工程师背景和 TypeScript 学习需求,我建议...
[使用 Memory 提供个性化建议]

interface VectorStoreSelection {
  scenario: string;
  recommendation: string;
  reason: string;
}

const selections: VectorStoreSelection[] = [
  {
    scenario: '原型/学习',
    recommendation: 'Chroma / FAISS / In-Memory',
    reason: '快速上手,零成本,适合实验'
  },
  {
    scenario: '内部工具',
    recommendation: 'PGVector / Supabase',
    reason: '与现有数据库集成,统一管理'
  },
  {
    scenario: '生产环境',
    recommendation: 'Pinecone / Weaviate',
    reason: '稳定可靠,性能优秀,专业支持'
  },
  {
    scenario: '数据敏感',
    recommendation: 'Chroma / Qdrant (自托管)',
    reason: '完全控制,数据不出本地'
  },
  {
    scenario: '大规模',
    recommendation: 'Pinecone / Weaviate',
    reason: '支持水平扩展,高并发'
  }
];

// Pinecone 集成示例
const pineconeConfig = {
  apiKey: process.env.PINECONE_API_KEY,
  environment: 'us-west1-gcp',
  indexName: 'my-knowledge-base'
};

// 添加文档
await pinecone.upsert({
  vectors: [
    {
      id: 'doc1',
      values: embedding,
      metadata: {
        text: 'document content',
        source: 'manual'
      }
    }
  ]
});

// 查询
const results = await pinecone.query({
  vector: queryEmbedding,
  topK: 3,
  includeMetadata: true
});

Agent = LLM + Memory + Tools + Orchestration

Memory: 个性化上下文,会话状态
RAG: 外部知识,事实依据

没有 Vector Store → 无法实现高效 RAG
没有 RAG → Agent 只能"空谈"

Memory 设计 = 性能 + 成本 + 用户体验 的平衡

系统设计 > 单点优化

// 模式 1: 分层 Memory
interface LayeredMemory {
  immediate: Message[];      // 最近 3 轮
  session: Summary;          // 本次会话摘要
  longTerm: UserProfile;     // 长期用户画像
}

// 模式 2: 选择性 Memory
const memoryFilter = {
  storePreferences: true,
  storeDecisions: true,
  storeSmallTalk: false,
  storeSensitiveInfo: false
};

// 模式 3: 摘要化 Memory
const summarizeOldMessages = async (messages: Message[]) => {
  if (messages.length > 20) {
    const oldMessages = messages.slice(0, -10);
    const summary = await llm.summarize(oldMessages);
    return [summary, ...messages.slice(-10)];
  }
  return messages;
};

// 1. Token 优化
const optimizeMemory = {
  windowSize: 5,           // 限制窗口
  maxTokens: 2000,         // 限制总量
  summarizeThreshold: 10   // 超过阈值摘要化
};

// 2. 缓存策略
const cache = new Map<string, Embedding>();
const getEmbedding = async (text: string) => {
  if (cache.has(text)) {
    return cache.get(text);
  }
  const embedding = await embeddingModel.embed(text);
  cache.set(text, embedding);
  return embedding;
};

// 3. 批量处理
const batchSize = 100;
const batches = chunkArray(documents, batchSize);
for (const batch of batches) {
  await vectorStore.addDocuments(batch);
}

// 1. Multi-Tool Agent
interface MultiToolAgent {
  tools: {
    search: GoogleSearchTool;
    database: DatabaseTool;
    api: CustomAPITool;
    calculator: CalculatorTool;
  };
  
  async execute(task: string): Promise<Result> {
    const plan = await this.plan(task);
    for (const step of plan) {
      const tool = this.selectTool(step);
      await tool.execute(step.params);
    }
  }
}

// 2. Hierarchical Agent
interface HierarchicalAgent {
  coordinator: Agent;
  specialists: {
    research: ResearchAgent;
    writing: WritingAgent;
    coding: CodingAgent;
  };
}

// 3. Self-Improving Agent
interface SelfImprovingAgent extends Agent {
  feedback: FeedbackSystem;
  
  async learn(interaction: Interaction): Promise<void> {
    const feedback = await this.feedback.evaluate(interaction);
    if (feedback.shouldUpdate) {
      await this.updateStrategy(feedback);
    }
  }
}

interface AdvancedProject {
  name: string;
  complexity: 'medium' | 'high' | 'expert';
  technologies: string[];
}

const projects: AdvancedProject[] = [
  {
    name: '个性化学习助手',
    complexity: 'medium',
    technologies: ['Memory', 'RAG', 'Progress Tracking']
  },
  {
    name: '企业知识库问答',
    complexity: 'high',
    technologies: ['Vector Store', 'RAG', 'Multi-Source']
  },
  {
    name: '自主研究 Agent',
    complexity: 'expert',
    technologies: ['Multi-Tool', 'Planning', 'Self-Reflection']
  }
];