iconsulting/DEVELOPMENT_GUIDE.md

1323 lines
43 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# iConsulting - 香港移民在线咨询系统开发指导
## 项目概述
iConsulting 是一个基于 Claude Agent SDK 的智能在线客服系统,专注于提供香港移民咨询服务。系统具备自我进化能力,能够从用户对话中学习经验,并根据管理员意图持续优化服务。
### 核心特性
- **智能咨询**: 基于 Claude Agent SDK 的自然语言对话
- **付费评估**: 移民资格评估服务,支持多种支付方式
- **知识增强**: RAG + 知识图谱,提供准确专业的回答
- **自我进化**: 从对话中学习,根据管理员指令调整
- **长期记忆**: 基于时间线的知识图谱记录
---
## 技术架构
### 整体架构图
```
┌─────────────────────────────────────────────────────────────────────┐
│ 客户端层 (Client Layer) │
├─────────────────────────────────────────────────────────────────────┤
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────────────────┐ │
│ │ PC Web │ │ H5 Mobile │ │ Admin Dashboard │ │
│ │ (React+TS) │ │ (React+TS) │ │ (React+TS) │ │
│ └──────────────┘ └──────────────┘ └──────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────┐
│ API 网关层 (API Gateway) │
├─────────────────────────────────────────────────────────────────────┤
│ - 路由分发 - 认证授权 - 限流熔断 - 日志追踪 │
│ - WebSocket 代理 - 请求聚合 │
└─────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────┐
│ 微服务层 (Microservices) │
├─────────────────────────────────────────────────────────────────────┤
│ ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐ │
│ │ User │ │ Conversation│ │ Knowledge │ │ Payment │ │
│ │ Service │ │ Service │ │ Service │ │ Service │ │
│ │ │ │ │ │ │ │ │ │
│ │ - 匿名用户 │ │ - Claude │ │ - RAG引擎 │ │ - 支付宝 │ │
│ │ - 手机验证 │ │ Agent │ │ - 向量检索 │ │ - 微信支付 │ │
│ │ - 会话管理 │ │ - 对话管理 │ │ - 知识图谱 │ │ - 信用卡 │ │
│ │ - 用户画像 │ │ - 流式输出 │ │ - 长期记忆 │ │ - 订单管理 │ │
│ └────────────┘ └────────────┘ └────────────┘ └────────────┘ │
│ │
│ ┌────────────┐ ┌────────────┐ │
│ │ Admin │ │ Evolution │ │
│ │ Service │ │ Service │ │
│ │ │ │ │ │
│ │ - 后台管理 │ │ - 经验提取 │ │
│ │ - 角色权限 │ │ - 模式识别 │ │
│ │ - 系统配置 │ │ - 自我调整 │ │
│ │ - 数据统计 │ │ - 管理员交互│ │
│ └────────────┘ └────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────┐
│ 基础设施层 (Infrastructure) │
├─────────────────────────────────────────────────────────────────────┤
│ ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐ │
│ │ PostgreSQL │ │ Neo4j │ │ Redis │ │ Kafka │ │
│ │ │ │ │ │ │ │ │ │
│ │ - 用户数据 │ │ - 知识图谱 │ │ - 会话缓存 │ │ - 事件驱动 │ │
│ │ - 订单数据 │ │ - 长期记忆 │ │ - 分布式锁 │ │ - Outbox │ │
│ │ - 配置数据 │ │ - 关系网络 │ │ - 限流计数 │ │ - 消息队列 │ │
│ └────────────┘ └────────────┘ └────────────┘ └────────────┘ │
│ │
│ ┌────────────┐ ┌────────────┐ │
│ │ Anthropic │ │ 向量数据库 │ │
│ │ Claude API │ │ (pgvector) │ │
│ └────────────┘ └────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
```
### 技术栈详情
| 层次 | 技术选型 | 说明 |
|------|---------|------|
| 前端 | React 18 + TypeScript | Clean Architecture |
| 前端UI | TailwindCSS + Radix UI | 响应式设计 |
| 前端状态 | Zustand + React Query | 轻量高效 |
| 后端框架 | NestJS | DDD + Hexagonal Architecture |
| API协议 | REST + WebSocket | 实时对话支持 |
| 主数据库 | PostgreSQL 15 | 结构化数据存储 |
| 向量数据库 | pgvector | RAG 向量检索 |
| 图数据库 | Neo4j | 知识图谱 + 长期记忆 |
| 缓存 | Redis | 会话 + 缓存 |
| 消息队列 | Kafka | 事件驱动 + Outbox模式 |
| AI引擎 | Claude Agent SDK | 对话 + 推理 |
---
## 项目目录结构
```
iconsulting/
├── docs/ # 项目文档
│ ├── architecture/ # 架构设计文档
│ ├── api/ # API 文档
│ └── deployment/ # 部署文档
├── packages/ # Monorepo 包管理
│ ├── shared/ # 共享代码
│ │ ├── types/ # TypeScript 类型定义
│ │ ├── utils/ # 工具函数
│ │ └── constants/ # 常量定义
│ │
│ ├── web-client/ # 用户端 Web 应用 (PC/H5)
│ │ ├── src/
│ │ │ ├── app/ # 应用层
│ │ │ │ ├── providers/ # Context Providers
│ │ │ │ ├── routes/ # 路由配置
│ │ │ │ └── App.tsx
│ │ │ ├── features/ # 功能模块 (Clean Architecture)
│ │ │ │ ├── chat/ # 聊天功能
│ │ │ │ │ ├── domain/ # 领域层
│ │ │ │ │ ├── data/ # 数据层
│ │ │ │ │ └── presentation/# 表现层
│ │ │ │ ├── payment/ # 支付功能
│ │ │ │ └── user/ # 用户功能
│ │ │ ├── shared/ # 共享组件
│ │ │ │ ├── components/ # UI 组件
│ │ │ │ ├── hooks/ # 自定义 Hooks
│ │ │ │ └── utils/ # 工具函数
│ │ │ └── main.tsx
│ │ ├── package.json
│ │ └── vite.config.ts
│ │
│ ├── admin-client/ # 管理端 Web 应用
│ │ ├── src/
│ │ │ ├── app/
│ │ │ ├── features/
│ │ │ │ ├── dashboard/ # 仪表盘
│ │ │ │ ├── knowledge/ # 知识库管理
│ │ │ │ ├── evolution/ # 进化管理
│ │ │ │ ├── users/ # 用户管理
│ │ │ │ ├── orders/ # 订单管理
│ │ │ │ └── settings/ # 系统设置
│ │ │ └── shared/
│ │ └── package.json
│ │
│ └── services/ # 后端微服务
│ ├── api-gateway/ # API 网关
│ │ ├── src/
│ │ │ ├── main.ts
│ │ │ ├── gateway.module.ts
│ │ │ └── middleware/
│ │ └── package.json
│ │
│ ├── user-service/ # 用户服务
│ │ ├── src/
│ │ │ ├── domain/ # 领域层
│ │ │ │ ├── entities/
│ │ │ │ ├── value-objects/
│ │ │ │ ├── repositories/
│ │ │ │ └── services/
│ │ │ ├── application/ # 应用层
│ │ │ │ ├── commands/
│ │ │ │ ├── queries/
│ │ │ │ └── services/
│ │ │ ├── infrastructure/ # 基础设施层
│ │ │ │ ├── persistence/
│ │ │ │ ├── messaging/
│ │ │ │ └── external/
│ │ │ └── interfaces/ # 接口层
│ │ │ ├── http/
│ │ │ └── grpc/
│ │ └── package.json
│ │
│ ├── conversation-service/ # 对话服务 (核心)
│ │ ├── src/
│ │ │ ├── domain/
│ │ │ │ ├── entities/
│ │ │ │ │ ├── conversation.entity.ts
│ │ │ │ │ ├── message.entity.ts
│ │ │ │ │ └── session.entity.ts
│ │ │ │ ├── value-objects/
│ │ │ │ ├── repositories/
│ │ │ │ └── services/
│ │ │ │ └── claude-agent.service.ts
│ │ │ ├── application/
│ │ │ │ ├── commands/
│ │ │ │ │ ├── send-message.command.ts
│ │ │ │ │ └── start-conversation.command.ts
│ │ │ │ └── services/
│ │ │ │ └── conversation.service.ts
│ │ │ ├── infrastructure/
│ │ │ │ ├── claude/ # Claude Agent SDK 集成
│ │ │ │ │ ├── claude-client.ts
│ │ │ │ │ ├── tools/ # Agent Tools
│ │ │ │ │ └── prompts/
│ │ │ │ └── persistence/
│ │ │ └── interfaces/
│ │ │ ├── http/
│ │ │ └── websocket/
│ │ └── package.json
│ │
│ ├── knowledge-service/ # 知识服务
│ │ ├── src/
│ │ │ ├── domain/
│ │ │ │ ├── entities/
│ │ │ │ │ ├── document.entity.ts
│ │ │ │ │ ├── knowledge-node.entity.ts
│ │ │ │ │ └── memory.entity.ts
│ │ │ │ └── services/
│ │ │ │ ├── rag.service.ts
│ │ │ │ └── graph.service.ts
│ │ │ ├── application/
│ │ │ ├── infrastructure/
│ │ │ │ ├── vector-store/ # pgvector
│ │ │ │ ├── graph-db/ # Neo4j
│ │ │ │ └── embedding/ # 向量化
│ │ │ └── interfaces/
│ │ └── package.json
│ │
│ ├── payment-service/ # 支付服务
│ │ ├── src/
│ │ │ ├── domain/
│ │ │ │ ├── entities/
│ │ │ │ │ ├── order.entity.ts
│ │ │ │ │ └── payment.entity.ts
│ │ │ │ └── services/
│ │ │ ├── application/
│ │ │ ├── infrastructure/
│ │ │ │ ├── alipay/ # 支付宝
│ │ │ │ ├── wechat-pay/ # 微信支付
│ │ │ │ └── stripe/ # 信用卡(Stripe)
│ │ │ └── interfaces/
│ │ └── package.json
│ │
│ ├── admin-service/ # 管理服务
│ │ ├── src/
│ │ │ ├── domain/
│ │ │ │ ├── entities/
│ │ │ │ │ ├── admin-user.entity.ts
│ │ │ │ │ ├── role.entity.ts
│ │ │ │ │ └── system-config.entity.ts
│ │ │ │ └── services/
│ │ │ ├── application/
│ │ │ ├── infrastructure/
│ │ │ └── interfaces/
│ │ └── package.json
│ │
│ └── evolution-service/ # 进化服务 (核心)
│ ├── src/
│ │ ├── domain/
│ │ │ ├── entities/
│ │ │ │ ├── experience.entity.ts
│ │ │ │ ├── pattern.entity.ts
│ │ │ │ └── evolution-log.entity.ts
│ │ │ └── services/
│ │ │ ├── experience-extractor.service.ts
│ │ │ ├── pattern-recognizer.service.ts
│ │ │ └── evolution-engine.service.ts
│ │ ├── application/
│ │ │ ├── commands/
│ │ │ │ ├── extract-experience.command.ts
│ │ │ │ └── apply-evolution.command.ts
│ │ │ └── services/
│ │ ├── infrastructure/
│ │ │ ├── analyzers/ # 分析器
│ │ │ └── adapters/ # 适配器
│ │ └── interfaces/
│ └── package.json
├── infrastructure/ # 基础设施配置
│ ├── docker/
│ │ ├── docker-compose.yml
│ │ ├── docker-compose.dev.yml
│ │ └── services/
│ │ ├── postgres/
│ │ ├── neo4j/
│ │ ├── redis/
│ │ └── kafka/
│ ├── k8s/ # Kubernetes 配置 (可选)
│ └── scripts/ # 部署脚本
├── package.json # Root package.json
├── pnpm-workspace.yaml # pnpm workspace 配置
├── turbo.json # Turborepo 配置
├── tsconfig.base.json # TypeScript 基础配置
├── .env.example # 环境变量示例
└── README.md # 项目说明
```
---
## 核心模块设计
### 1. 对话服务 (Conversation Service)
#### Claude Agent SDK 集成
```typescript
// conversation-service/src/infrastructure/claude/claude-client.ts
import Anthropic from '@anthropic-ai/sdk';
import { Injectable } from '@nestjs/common';
@Injectable()
export class ClaudeAgentClient {
private client: Anthropic;
constructor(private configService: ConfigService) {
this.client = new Anthropic({
apiKey: this.configService.get('ANTHROPIC_API_KEY'),
});
}
async createConversation(
systemPrompt: string,
tools: Tool[],
): Promise<ConversationSession> {
// 创建带有工具的对话会话
}
async sendMessage(
sessionId: string,
message: string,
context: ConversationContext,
): AsyncGenerator<StreamChunk> {
// 流式发送消息并获取响应
}
}
```
#### 对话工具定义
系统需要定义以下 Agent Tools
1. **知识检索工具** - 从 RAG 系统检索相关知识
2. **评估工具** - 收集用户信息进行移民评估
3. **支付工具** - 生成支付二维码
4. **记忆工具** - 读写长期记忆
```typescript
// conversation-service/src/infrastructure/claude/tools/index.ts
export const immigrationTools = [
{
name: 'search_knowledge',
description: '搜索香港移民相关知识库',
input_schema: {
type: 'object',
properties: {
query: { type: 'string', description: '搜索查询' },
category: {
type: 'string',
enum: ['优才计划', '专才计划', '留学IANG', '高才通', '投资移民', '科技人才'],
description: '移民类别'
}
},
required: ['query']
}
},
{
name: 'start_assessment',
description: '开始移民资格评估(付费服务)',
input_schema: {
type: 'object',
properties: {
category: { type: 'string', description: '评估的移民类别' },
user_info: { type: 'object', description: '用户基本信息' }
},
required: ['category']
}
},
{
name: 'generate_payment',
description: '生成支付二维码',
input_schema: {
type: 'object',
properties: {
amount: { type: 'number', description: '支付金额' },
service_type: { type: 'string', description: '服务类型' },
payment_method: {
type: 'string',
enum: ['alipay', 'wechat', 'credit_card'],
description: '支付方式'
}
},
required: ['amount', 'service_type', 'payment_method']
}
},
{
name: 'check_off_topic',
description: '检查问题是否与移民相关',
input_schema: {
type: 'object',
properties: {
question: { type: 'string', description: '用户问题' }
},
required: ['question']
}
}
];
```
#### 系统提示词设计
```typescript
// conversation-service/src/infrastructure/claude/prompts/system-prompt.ts
export const buildSystemPrompt = (config: SystemConfig): string => `
你是 iConsulting 的香港移民咨询顾问,专门为用户提供香港各类移民政策的咨询服务。
## 身份定位
${config.identity || '专业、友善、耐心的移民顾问'}
## 服务范围
你只回答与香港移民相关的问题包括以下6大类别
### 1. 优才计划 (QMAS - Quality Migrant Admission Scheme)
- **目的**: 吸纳优秀人才来港定居
- **审核标准**: 年龄、教育经历、工作经验、语言能力、年收入证明、良好品格、是否持有公司等
- **人才类型**: 行业翘楚、精英人士
- **名额**: 暂无名额限制
- **申请要点**: 年龄、教育经历、工作经验、年收入证明、良好品格,是否符合等方面的要求(共12项)满足其中6项为基本门槛择优批准
### 2. 专才计划 (GEP - General Employment Policy)
- **目的**: 吸引专业人才来港就业
- **审核标准**: 雇佣企业的行业背景、行业内的地位、政策扶持力度、所属行业经济地位
- **人才类型**: 专业人士(≥200万年薪属于人才清单)
- **名额**: 无配额限制(不限行业)
- **申请要点**: 必须有雇主担保、要保持工作连续性(被裁3个月内)、工作和居住在非粤港澳、申请前至少有一年半社保记录、提供所在公司配套宣传图
### 3. 留学IANG (Immigration Arrangements for Non-local Graduates)
- **目的**: 吸引优秀学生人才来港续读
- **审核标准**: 有无完成学业、是否有雇主担保
- **人才类型**: 成绩优异、拥有国际化视野的学生
- **名额**: 扩展到本港大学大湾区校区毕业生为期2年、1年后续签
- **申请要点**: 必须有雇主担保、要保持工作连续性
### 4. 高才通计划 (TTPS - Top Talent Pass Scheme)
- **目的**: 吸引高端人才来港
- **审核标准**:
- A类: 年薪≥250万港币
- B类: 毕业于世界前100名大学5年内有3年以上工作经验
- C类: 毕业于世界前100名大学5年内有少于3年工作经验(年度限额10,000名)
- **人才类型**: 顶尖人才
- **名额**: 无限期计划(推出后制一进行检讨)
### 5. 投资移民 (新资本投资者入境计划)
- **目的**: 吸引投资者
- **审核标准**: 投资不少于3,000万港币(或等值外币)净资产于其指定对实益拥有者的许可投资
- **人才类型**: 投资者
- **名额**: 无名额限制
- **申请要点**: 资产审查新政3月1日起申请人只须证明在提出申请六个月前已期限内持有该资产(1,000万元额度可获考虑)
### 6. 科技人才入境计划 (TechTAS)
- **目的**: 吸引科技人才来港就业
- **审核标准**: 申请人主要从事先进通讯技术、人工智能、生物科技、网络安全、数据分析、数码娱乐、金融科技、绿色科技、集成电路设计、物联网、材料科学、微电子、量子科技、机械人技术等研究工作;申请薪酬应不低于香港特区该业务的市场薪酬水平
- **人才类型**: 科技人才
- **名额**: 需用公司高新创新科技营配出有效配额
- **申请要点**: 由符合创新科技署发出的获配证出有效配额
## 行为准则
1. 如果用户询问与移民无关的问题,礼貌地引导回移民话题
2. 对于复杂的评估需求,建议使用付费评估服务
3. 提供信息时注明信息来源和更新时间
4. 不做任何法律承诺或申请成功率的保证
## 付费服务
当用户需要个性化移民评估时,介绍付费评估服务:
- 说明服务内容和价值
- 确认用户意愿后生成支付码
## 对话风格
${config.conversationStyle || '专业但不生硬,用简洁明了的语言解答'}
## 已积累的经验
${config.accumulatedExperience || '暂无'}
## 管理员特别指示
${config.adminInstructions || '暂无'}
`;
```
### 2. 知识服务 (Knowledge Service)
#### RAG 架构
```typescript
// knowledge-service/src/domain/services/rag.service.ts
@Injectable()
export class RAGService {
constructor(
private vectorStore: VectorStoreRepository,
private embeddingService: EmbeddingService,
private graphService: GraphService,
) {}
async search(query: string, options: SearchOptions): Promise<SearchResult[]> {
// 1. 向量相似度搜索
const embedding = await this.embeddingService.embed(query);
const vectorResults = await this.vectorStore.search(embedding, options.limit);
// 2. 图谱增强(可选)
if (options.useGraph) {
const graphContext = await this.graphService.getRelatedNodes(
vectorResults.map(r => r.nodeId)
);
return this.mergeResults(vectorResults, graphContext);
}
return vectorResults;
}
async addDocument(doc: Document): Promise<void> {
// 1. 文档分块
const chunks = await this.chunkDocument(doc);
// 2. 向量化并存储
for (const chunk of chunks) {
const embedding = await this.embeddingService.embed(chunk.content);
await this.vectorStore.insert({
content: chunk.content,
embedding,
metadata: chunk.metadata,
});
}
// 3. 更新知识图谱
await this.graphService.addDocumentNodes(doc, chunks);
}
}
```
#### 知识图谱 (Neo4j)
```typescript
// knowledge-service/src/infrastructure/graph-db/neo4j.repository.ts
@Injectable()
export class Neo4jRepository {
constructor(private neo4jService: Neo4jService) {}
// 添加用户记忆节点
async addMemory(memory: Memory): Promise<void> {
await this.neo4jService.write(`
MERGE (u:User {id: $userId})
CREATE (m:Memory {
id: $memoryId,
content: $content,
timestamp: datetime($timestamp),
type: $type
})
CREATE (u)-[:HAS_MEMORY {timestamp: datetime($timestamp)}]->(m)
`, {
userId: memory.userId,
memoryId: memory.id,
content: memory.content,
timestamp: memory.timestamp.toISOString(),
type: memory.type,
});
}
// 获取用户时间线记忆
async getUserTimeline(userId: string, limit: number = 50): Promise<Memory[]> {
const result = await this.neo4jService.read(`
MATCH (u:User {id: $userId})-[r:HAS_MEMORY]->(m:Memory)
RETURN m
ORDER BY m.timestamp DESC
LIMIT $limit
`, { userId, limit });
return result.records.map(r => this.mapToMemory(r.get('m')));
}
// 知识关联查询
async getRelatedKnowledge(topic: string): Promise<KnowledgeNode[]> {
const result = await this.neo4jService.read(`
MATCH (n:Knowledge)-[r:RELATED_TO*1..2]-(related)
WHERE n.topic CONTAINS $topic
RETURN n, related, r
`, { topic });
return this.mapToKnowledgeNodes(result);
}
}
```
### 3. 进化服务 (Evolution Service)
这是系统的核心创新点,实现自我学习和进化。
#### 经验提取器
```typescript
// evolution-service/src/domain/services/experience-extractor.service.ts
@Injectable()
export class ExperienceExtractorService {
constructor(
private claudeClient: ClaudeAgentClient,
private experienceRepo: ExperienceRepository,
) {}
// 从对话中提取经验
async extractFromConversation(conversation: Conversation): Promise<Experience[]> {
const prompt = `
分析以下对话,提取有价值的经验:
1. 用户常见问题模式
2. 有效的回答策略
3. 用户满意度信号
4. 需要改进的地方
对话内容:
${JSON.stringify(conversation.messages)}
请以JSON格式返回经验列表。
`;
const response = await this.claudeClient.analyze(prompt);
return this.parseExperiences(response);
}
// 定期批量分析
async batchAnalyze(): Promise<AnalysisReport> {
const conversations = await this.getRecentConversations();
const prompt = `
分析以下 ${conversations.length} 个对话,总结:
1. 高频问题 TOP 10
2. 用户最关心的移民类别
3. 转化率较高的话术
4. 常见的用户困惑点
5. 建议的系统改进方向
请生成详细的分析报告。
`;
return await this.claudeClient.analyze(prompt);
}
}
```
#### 进化引擎
```typescript
// evolution-service/src/domain/services/evolution-engine.service.ts
@Injectable()
export class EvolutionEngineService {
constructor(
private experienceRepo: ExperienceRepository,
private configService: SystemConfigService,
private claudeClient: ClaudeAgentClient,
) {}
// 与管理员对话,理解意图
async interactWithAdmin(
adminMessage: string,
context: AdminContext,
): Promise<EvolutionResponse> {
const experiences = await this.experienceRepo.getRecentExperiences();
const currentConfig = await this.configService.getCurrentConfig();
const prompt = `
你是 iConsulting 系统的进化引擎。
## 当前系统配置
${JSON.stringify(currentConfig)}
## 近期积累的经验
${JSON.stringify(experiences)}
## 管理员指令
${adminMessage}
## 任务
1. 理解管理员的意图
2. 基于积累的经验,提出具体的调整方案
3. 生成新的配置或行为规则
请返回:
- 对管理员意图的理解
- 建议的调整方案
- 需要确认的事项(如有)
`;
return await this.claudeClient.analyze(prompt);
}
// 应用进化
async applyEvolution(evolution: Evolution): Promise<void> {
// 更新系统提示词
if (evolution.promptChanges) {
await this.configService.updatePrompt(evolution.promptChanges);
}
// 更新知识库
if (evolution.knowledgeChanges) {
await this.knowledgeService.applyChanges(evolution.knowledgeChanges);
}
// 更新业务规则
if (evolution.ruleChanges) {
await this.configService.updateRules(evolution.ruleChanges);
}
// 记录进化日志
await this.evolutionLogRepo.save({
timestamp: new Date(),
changes: evolution,
triggeredBy: evolution.adminId,
});
}
}
```
### 4. 支付服务 (Payment Service)
```typescript
// payment-service/src/infrastructure/alipay/alipay.adapter.ts
@Injectable()
export class AlipayAdapter implements PaymentGateway {
constructor(private configService: ConfigService) {
this.alipay = new AlipaySdk({
appId: this.configService.get('ALIPAY_APP_ID'),
privateKey: this.configService.get('ALIPAY_PRIVATE_KEY'),
// ...
});
}
async createPayment(order: Order): Promise<PaymentResult> {
const result = await this.alipay.exec('alipay.trade.precreate', {
bizContent: {
out_trade_no: order.id,
total_amount: order.amount.toString(),
subject: order.subject,
}
});
return {
qrCode: result.qrCode,
orderId: order.id,
expireAt: new Date(Date.now() + 30 * 60 * 1000), // 30分钟有效
};
}
async handleCallback(payload: AlipayCallback): Promise<void> {
// 验签并处理回调
}
}
```
### 5. 用户服务 (User Service)
#### 匿名用户处理
```typescript
// user-service/src/domain/entities/user.entity.ts
export class User extends AggregateRoot {
id: UserId;
type: UserType; // ANONYMOUS | REGISTERED
fingerprint?: string;
phone?: string;
createdAt: Date;
lastActiveAt: Date;
static createAnonymous(fingerprint: string): User {
return new User({
id: UserId.generate(),
type: UserType.ANONYMOUS,
fingerprint,
createdAt: new Date(),
lastActiveAt: new Date(),
});
}
upgradeToRegistered(phone: string): void {
this.phone = phone;
this.type = UserType.REGISTERED;
this.addDomainEvent(new UserUpgradedEvent(this.id, phone));
}
}
```
---
## 数据模型设计
### PostgreSQL 表结构
```sql
-- 用户表
CREATE TABLE users (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
type VARCHAR(20) NOT NULL DEFAULT 'ANONYMOUS',
fingerprint VARCHAR(255),
phone VARCHAR(20),
created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
last_active_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);
-- 对话表
CREATE TABLE conversations (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID REFERENCES users(id),
status VARCHAR(20) NOT NULL DEFAULT 'ACTIVE',
created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
ended_at TIMESTAMP WITH TIME ZONE
);
-- 消息表
CREATE TABLE messages (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
conversation_id UUID REFERENCES conversations(id),
role VARCHAR(20) NOT NULL, -- user, assistant, system
content TEXT NOT NULL,
metadata JSONB,
created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);
-- 订单表
CREATE TABLE orders (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID REFERENCES users(id),
service_type VARCHAR(50) NOT NULL,
amount DECIMAL(10, 2) NOT NULL,
status VARCHAR(20) NOT NULL DEFAULT 'PENDING',
payment_method VARCHAR(20),
paid_at TIMESTAMP WITH TIME ZONE,
created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);
-- 发件箱表 (Outbox Pattern)
CREATE TABLE outbox (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
aggregate_type VARCHAR(100) NOT NULL,
aggregate_id UUID NOT NULL,
event_type VARCHAR(100) NOT NULL,
payload JSONB NOT NULL,
created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
processed_at TIMESTAMP WITH TIME ZONE
);
-- 知识文档表
CREATE TABLE documents (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
title VARCHAR(255) NOT NULL,
content TEXT NOT NULL,
category VARCHAR(50),
metadata JSONB,
created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);
-- 向量存储表 (pgvector)
CREATE TABLE document_embeddings (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
document_id UUID REFERENCES documents(id),
chunk_index INT NOT NULL,
content TEXT NOT NULL,
embedding vector(1536),
metadata JSONB,
created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);
-- 系统配置表
CREATE TABLE system_configs (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
key VARCHAR(100) UNIQUE NOT NULL,
value JSONB NOT NULL,
updated_by UUID,
updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);
-- 管理员表
CREATE TABLE admin_users (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
username VARCHAR(100) UNIQUE NOT NULL,
password_hash VARCHAR(255) NOT NULL,
role VARCHAR(50) NOT NULL,
created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);
-- 进化日志表
CREATE TABLE evolution_logs (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
triggered_by UUID REFERENCES admin_users(id),
change_type VARCHAR(50) NOT NULL,
changes JSONB NOT NULL,
created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);
```
### Neo4j 图模型
```cypher
// 用户节点
(:User {
id: string,
type: string,
createdAt: datetime
})
// 记忆节点
(:Memory {
id: string,
content: string,
type: string, // FACT, PREFERENCE, INTERACTION
timestamp: datetime
})
// 知识节点
(:Knowledge {
id: string,
topic: string,
content: string,
category: string,
updatedAt: datetime
})
// 经验节点
(:Experience {
id: string,
pattern: string,
insight: string,
frequency: int,
createdAt: datetime
})
// 关系定义
(User)-[:HAS_MEMORY {timestamp}]->(Memory)
(User)-[:ASKED_ABOUT]->(Knowledge)
(Knowledge)-[:RELATED_TO {weight}]->(Knowledge)
(Experience)-[:DERIVED_FROM]->(Conversation)
(Experience)-[:INFLUENCES]->(SystemConfig)
```
---
## API 设计
### REST API
```yaml
# 用户端 API
/api/v1:
/auth:
/anonymous:
POST: 创建匿名会话
/verify-phone:
POST: 发送验证码
/login:
POST: 手机号登录
/conversations:
POST: 创建新对话
GET: 获取对话列表
/{id}:
GET: 获取对话详情
/messages:
POST: 发送消息 (HTTP)
/payments:
POST: 创建支付订单
/{id}/status:
GET: 查询支付状态
# 管理端 API
/admin/api/v1:
/auth:
/login:
POST: 管理员登录
/knowledge:
GET: 获取知识列表
POST: 添加知识
/{id}:
PUT: 更新知识
DELETE: 删除知识
/upload:
POST: 上传文档
/evolution:
/chat:
POST: 与系统进化引擎对话
/experiences:
GET: 获取经验总结
/apply:
POST: 应用进化变更
/configs:
GET: 获取配置
PUT: 更新配置
/analytics:
/dashboard:
GET: 获取仪表盘数据
/conversations:
GET: 对话统计
/payments:
GET: 支付统计
```
### WebSocket API
```typescript
// 对话 WebSocket
ws://host/ws/conversation
// 客户端 -> 服务端
{
type: 'message',
conversationId: 'uuid',
content: '用户消息'
}
// 服务端 -> 客户端 (流式)
{
type: 'stream_start',
messageId: 'uuid'
}
{
type: 'stream_chunk',
messageId: 'uuid',
content: '部分内容',
index: 0
}
{
type: 'stream_end',
messageId: 'uuid'
}
{
type: 'tool_call',
tool: 'generate_payment',
result: { qrCode: '...', orderId: '...' }
}
```
---
## 前端架构 (Clean Architecture)
### 目录结构详解
```
features/chat/
├── domain/ # 领域层
│ ├── entities/
│ │ ├── Message.ts # 消息实体
│ │ └── Conversation.ts # 对话实体
│ ├── repositories/
│ │ └── IChatRepository.ts # 仓储接口
│ └── usecases/
│ ├── SendMessageUseCase.ts
│ └── GetConversationUseCase.ts
├── data/ # 数据层
│ ├── repositories/
│ │ └── ChatRepositoryImpl.ts
│ ├── datasources/
│ │ ├── ChatApiDataSource.ts
│ │ └── ChatWebSocketDataSource.ts
│ └── models/
│ ├── MessageModel.ts
│ └── ConversationModel.ts
└── presentation/ # 表现层
├── components/
│ ├── ChatWindow.tsx
│ ├── MessageBubble.tsx
│ ├── InputArea.tsx
│ └── PaymentModal.tsx
├── hooks/
│ ├── useChat.ts
│ └── useWebSocket.ts
├── stores/
│ └── chatStore.ts
└── pages/
└── ChatPage.tsx
```
### 核心组件示例
```tsx
// features/chat/presentation/components/ChatWindow.tsx
import { useChat } from '../hooks/useChat';
import { MessageBubble } from './MessageBubble';
import { InputArea } from './InputArea';
export const ChatWindow: React.FC = () => {
const {
messages,
isStreaming,
sendMessage,
currentStreamContent
} = useChat();
return (
<div className="flex flex-col h-screen">
<div className="flex-1 overflow-y-auto p-4 space-y-4">
{messages.map((msg) => (
<MessageBubble key={msg.id} message={msg} />
))}
{isStreaming && (
<MessageBubble
message={{ role: 'assistant', content: currentStreamContent }}
isStreaming
/>
)}
</div>
<InputArea onSend={sendMessage} disabled={isStreaming} />
</div>
);
};
```
---
## 部署方案
### Docker Compose (开发环境)
```yaml
# infrastructure/docker/docker-compose.dev.yml
version: '3.8'
services:
postgres:
image: pgvector/pgvector:pg15
environment:
POSTGRES_USER: iconsulting
POSTGRES_PASSWORD: dev_password
POSTGRES_DB: iconsulting
ports:
- "5432:5432"
volumes:
- postgres_data:/var/lib/postgresql/data
neo4j:
image: neo4j:5
environment:
NEO4J_AUTH: neo4j/dev_password
ports:
- "7474:7474"
- "7687:7687"
volumes:
- neo4j_data:/data
redis:
image: redis:7-alpine
ports:
- "6379:6379"
zookeeper:
image: confluentinc/cp-zookeeper:7.4.0
environment:
ZOOKEEPER_CLIENT_PORT: 2181
ports:
- "2181:2181"
kafka:
image: confluentinc/cp-kafka:7.4.0
depends_on:
- zookeeper
ports:
- "9092:9092"
environment:
KAFKA_BROKER_ID: 1
KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
volumes:
postgres_data:
neo4j_data:
```
---
## 开发计划
### Phase 1: 基础架构 (核心)
1. 项目初始化和工程配置
2. 数据库 Schema 和连接
3. 基础微服务框架搭建
4. API 网关配置
### Phase 2: 核心对话功能
1. Claude Agent SDK 集成
2. 对话服务完整实现
3. WebSocket 实时通信
4. 基础知识检索 (RAG)
### Phase 3: 支付和用户
1. 支付服务对接
2. 用户认证体系
3. 订单管理
### Phase 4: 知识和记忆
1. Neo4j 知识图谱
2. 长期记忆系统
3. RAG 优化
### Phase 5: 进化系统
1. 经验提取引擎
2. 管理员交互界面
3. 自动进化机制
### Phase 6: 管理后台
1. 管理员认证
2. 知识库管理
3. 系统配置
4. 数据统计
### Phase 7: 前端完善
1. 用户端 UI 完善
2. 管理端 UI 完善
3. 移动端适配
### Phase 8: 测试和优化
1. 单元测试
2. 集成测试
3. 性能优化
4. 安全审计
---
## 环境变量配置
```env
# .env.example
# Anthropic
ANTHROPIC_API_KEY=sk-ant-xxx
# PostgreSQL
POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_USER=iconsulting
POSTGRES_PASSWORD=your_password
POSTGRES_DB=iconsulting
# Neo4j
NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=your_password
# Redis
REDIS_HOST=localhost
REDIS_PORT=6379
# Kafka
KAFKA_BROKERS=localhost:9092
# 支付宝
ALIPAY_APP_ID=your_app_id
ALIPAY_PRIVATE_KEY=your_private_key
ALIPAY_PUBLIC_KEY=alipay_public_key
# 微信支付
WECHAT_APP_ID=your_app_id
WECHAT_MCH_ID=your_mch_id
WECHAT_API_KEY=your_api_key
# JWT
JWT_SECRET=your_jwt_secret
JWT_EXPIRES_IN=7d
# 服务端口
API_GATEWAY_PORT=3000
USER_SERVICE_PORT=3001
CONVERSATION_SERVICE_PORT=3002
KNOWLEDGE_SERVICE_PORT=3003
PAYMENT_SERVICE_PORT=3004
ADMIN_SERVICE_PORT=3005
EVOLUTION_SERVICE_PORT=3006
```
---
## 安全考虑
1. **API 安全**
- JWT 认证
- 请求限流
- 输入验证
- SQL 注入防护
2. **支付安全**
- 签名验证
- 回调白名单
- 金额校验
3. **数据安全**
- 敏感数据加密
- 日志脱敏
- 定期备份
4. **Claude API 安全**
- API Key 安全存储
- 输入内容过滤
- 输出内容审核
---
## 下一步行动
1. 确认移民类别列表(等待图片)
2. 创建项目目录结构
3. 初始化 Monorepo 配置
4. 搭建基础微服务框架
5. 集成 Claude Agent SDK
准备好后请告知,我将开始创建项目结构!