HaHafeng
7c3cc12b2e
P1 Architecture: Lightweight ReAct (Function Calling loop, max 3 rounds) Core changes: - Add ToolDefinition/ToolCall types to LLM adapters (DeepSeek + CloseAI + Claude) - Replace 6 old tools with 4 semantic tools: read_report, look_up_data, check_quality, search_knowledge - Create ChatOrchestrator (~160 lines) replacing ChatService (1,442 lines) - Wire WechatCallbackController to ChatOrchestrator, deprecate ChatService - Fix nullable content (string | null) across 12+ LLM consumer files E2E test results: 8/8 scenarios passed (100%) - QC report query, critical issues, patient data, trend, on-demand QC - Knowledge base search, project overview, data modification refusal Net code reduction: ~1,100 lines Tested: E2E P1 chat test 8/8 passed with DeepSeek API Made-with: Cursor
561 lines
18 KiB
TypeScript
561 lines
18 KiB
TypeScript
import { logger } from '../../../../common/logging/index.js';
|
||
import { LLMFactory } from '../../../../common/llm/adapters/LLMFactory.js';
|
||
import { ILLMAdapter, ModelType } from '../../../../common/llm/adapters/types.js';
|
||
import { cache } from '../../../../common/cache/index.js';
|
||
import { PromptBuilder, PICOSContext, DEFAULT_MVP_CONFIG } from './PromptBuilder.js';
|
||
import { ExtractionClient } from '../../../../common/document/ExtractionClient.js';
|
||
import { calculateTokens } from '../utils/tokenCalculator.js';
|
||
import { jsonrepair } from 'jsonrepair';
|
||
import * as crypto from 'crypto';
|
||
|
||
/**
|
||
* 模型名称映射：从用户友好的名称映射到内部ModelType
|
||
* 与标题摘要初筛保持一致
|
||
*/
|
||
const MODEL_NAME_MAP: Record<string, ModelType> = {
|
||
'deepseek-chat': 'deepseek-v3',
|
||
'deepseek-v3': 'deepseek-v3',
|
||
'qwen-max': 'qwen3-72b', // ⭐ qwen-max = Qwen最新最强模型
|
||
'qwen-plus': 'qwen3-72b', // qwen-plus = Qwen2.5-72B (次选)
|
||
'qwen3-72b': 'qwen3-72b',
|
||
'qwen-long': 'qwen-long',
|
||
'gpt-4o': 'gpt-5', // ⭐ gpt-4o 映射到 gpt-5
|
||
'gpt-5-pro': 'gpt-5',
|
||
'gpt-5': 'gpt-5',
|
||
'claude-sonnet-4.5': 'claude-4.5', // ⭐ claude-sonnet-4.5 映射
|
||
'claude-sonnet-4-5-20250929': 'claude-4.5',
|
||
'claude-4.5': 'claude-4.5',
|
||
};
|
||
|
||
/**
|
||
* LLM处理模式
|
||
*/
|
||
export enum LLM12FieldsMode {
|
||
SCREENING = '12fields-screening', // 评估模式（全文复筛）
|
||
EXTRACTION = '12fields-extraction', // 提取模式（全文提取，未来）
|
||
}
|
||
|
||
/**
|
||
* LLM处理结果
|
||
*/
|
||
export interface LLMResult {
|
||
result: any; // 解析后的JSON结果
|
||
processingTime: number; // 处理时间（毫秒）
|
||
tokenUsage: number; // Token使用量
|
||
cost: number; // 成本（人民币）
|
||
extractionMethod: string; // 'nougat' | 'pymupdf'
|
||
structuredFormat: boolean; // 是否为结构化格式（Markdown）
|
||
rawResponse: string; // 原始响应（用于调试）
|
||
}
|
||
|
||
/**
|
||
* Nougat提取选项
|
||
*/
|
||
interface NougatExtractionOptions {
|
||
preferNougat: boolean; // 是否优先使用Nougat（英文论文）
|
||
nougatQualityThreshold: number; // Nougat质量阈值（0.0-1.0，低于此值降级到PyMuPDF）
|
||
}
|
||
|
||
/**
|
||
* LLM 12字段处理服务
|
||
*
|
||
* 功能：
|
||
* 1. 全文提取（Nougat优先）
|
||
* 2. Prompt动态组装
|
||
* 3. LLM调用（支持DeepSeek-V3、Qwen3-Max等）
|
||
* 4. 结果缓存
|
||
* 5. 双模型并行调用
|
||
*/
|
||
export class LLM12FieldsService {
|
||
private promptBuilder: PromptBuilder;
|
||
private extractionClient: ExtractionClient;
|
||
private nougatOptions: NougatExtractionOptions;
|
||
|
||
constructor(options?: {
|
||
promptBuilder?: PromptBuilder;
|
||
extractionClient?: ExtractionClient;
|
||
nougatOptions?: Partial<NougatExtractionOptions>;
|
||
}) {
|
||
this.promptBuilder = options?.promptBuilder || new PromptBuilder();
|
||
this.extractionClient = options?.extractionClient || new ExtractionClient();
|
||
this.nougatOptions = {
|
||
preferNougat: true,
|
||
nougatQualityThreshold: 0.8,
|
||
...options?.nougatOptions,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 处理12字段（screening or extraction）
|
||
*
|
||
* 策略：全文一次性输入，通过Prompt工程优化
|
||
*/
|
||
async process12Fields(
|
||
mode: LLM12FieldsMode,
|
||
model: string, // 'deepseek-v3' | 'qwen-max' | 'deepseek-chat' 等用户友好名称
|
||
pdfBuffer: Buffer,
|
||
filename: string,
|
||
picosContext: PICOSContext
|
||
): Promise<LLMResult> {
|
||
const startTime = Date.now();
|
||
logger.info(`Starting 12-fields processing with model: ${model}, mode: ${mode}`);
|
||
|
||
// 映射模型名称到ModelType
|
||
const modelType = MODEL_NAME_MAP[model];
|
||
if (!modelType) {
|
||
throw new Error(
|
||
`Unsupported model name: ${model}. Supported models: ${Object.keys(MODEL_NAME_MAP).join(', ')}`
|
||
);
|
||
}
|
||
|
||
// Step 1: 提取全文（Nougat优先）
|
||
const { fullTextMarkdown, extractionMethod, structuredFormat } =
|
||
await this.extractFullTextStructured(pdfBuffer, filename);
|
||
|
||
logger.info(
|
||
`Full-text extracted, method: ${extractionMethod}, structured: ${structuredFormat}, length: ${fullTextMarkdown.length} chars`
|
||
);
|
||
|
||
// Step 2: 检查缓存
|
||
const cacheKey = this.generateCacheKey(mode, model, fullTextMarkdown, picosContext);
|
||
const cached = await this.checkCache(cacheKey);
|
||
if (cached) {
|
||
logger.info('Cache hit, returning cached result');
|
||
return cached;
|
||
}
|
||
|
||
// Step 3: 构建Prompt
|
||
const { systemPrompt, userPrompt } = await this.promptBuilder.buildFullPrompt({
|
||
picosContext,
|
||
fullTextContent: fullTextMarkdown,
|
||
documentFormat: structuredFormat ? 'markdown' : 'plaintext',
|
||
estimatedWordCount: Math.floor(fullTextMarkdown.length / 1.5), // 粗略估算字数
|
||
modelName: model,
|
||
includeCochraneStandards: DEFAULT_MVP_CONFIG.cochraneStandards,
|
||
includeFewShotExamples: DEFAULT_MVP_CONFIG.fewShotExamples,
|
||
});
|
||
|
||
logger.info(
|
||
`Prompt built, system: ${systemPrompt.length} chars, user: ${userPrompt.length} chars`
|
||
);
|
||
|
||
// Step 4: 调用LLM
|
||
const llmAdapter = LLMFactory.getAdapter(modelType);
|
||
const llmResponse = await this.callLLMWithRetry(
|
||
llmAdapter,
|
||
systemPrompt,
|
||
userPrompt,
|
||
mode
|
||
);
|
||
|
||
// Step 5: 解析结果
|
||
const parsedResult = this.parseResponse(llmResponse);
|
||
|
||
// Step 6: 计算Token和成本
|
||
const tokenUsage = calculateTokens(systemPrompt + userPrompt + llmResponse);
|
||
const cost = this.calculateCost(model, tokenUsage);
|
||
|
||
const result: LLMResult = {
|
||
result: parsedResult,
|
||
processingTime: Date.now() - startTime,
|
||
tokenUsage,
|
||
cost,
|
||
extractionMethod,
|
||
structuredFormat,
|
||
rawResponse: llmResponse,
|
||
};
|
||
|
||
// Step 7: 缓存结果
|
||
await this.cacheResult(cacheKey, result);
|
||
|
||
logger.info(
|
||
`12-fields processing completed, time: ${result.processingTime}ms, tokens: ${tokenUsage}, cost: ¥${cost.toFixed(4)}`
|
||
);
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 双模型并行调用（容错版本）
|
||
*
|
||
* 使用Promise.allSettled确保单个模型失败不影响另一个
|
||
*
|
||
* 容错策略：
|
||
* - 双模型成功：正常返回
|
||
* - 单模型失败：返回成功的模型结果，标记降级模式
|
||
* - 双模型失败：抛出异常
|
||
*/
|
||
async processDualModels(
|
||
mode: LLM12FieldsMode,
|
||
modelA: string = 'deepseek-v3',
|
||
modelB: string = 'qwen-max',
|
||
pdfBuffer: Buffer,
|
||
filename: string,
|
||
picosContext: PICOSContext
|
||
): Promise<{
|
||
resultA: LLMResult | null;
|
||
resultB: LLMResult | null;
|
||
degradedMode: boolean;
|
||
failedModel?: string;
|
||
}> {
|
||
logger.info(`Starting dual-model processing: ${modelA} + ${modelB}`);
|
||
|
||
// 使用allSettled确保一个失败不影响另一个
|
||
const [settledA, settledB] = await Promise.allSettled([
|
||
this.process12Fields(mode, modelA, pdfBuffer, filename, picosContext),
|
||
this.process12Fields(mode, modelB, pdfBuffer, filename, picosContext),
|
||
]);
|
||
|
||
// 提取结果
|
||
const resultA = settledA.status === 'fulfilled' ? settledA.value : null;
|
||
const resultB = settledB.status === 'fulfilled' ? settledB.value : null;
|
||
|
||
// ========================================
|
||
// 容错逻辑
|
||
// ========================================
|
||
|
||
// 情况1：双模型都失败 ❌
|
||
if (!resultA && !resultB) {
|
||
const errorA = settledA.status === 'rejected' ? settledA.reason : 'unknown';
|
||
const errorB = settledB.status === 'rejected' ? settledB.reason : 'unknown';
|
||
|
||
logger.error('Both models failed', {
|
||
modelA,
|
||
modelB,
|
||
errorA: errorA?.message || String(errorA),
|
||
errorB: errorB?.message || String(errorB)
|
||
});
|
||
|
||
throw new Error(
|
||
`Both models (${modelA} and ${modelB}) failed to process. ` +
|
||
`${modelA} error: ${errorA?.message || errorA}. ` +
|
||
`${modelB} error: ${errorB?.message || errorB}.`
|
||
);
|
||
}
|
||
|
||
// 情况2：模型A失败，使用模型B ⚠️
|
||
if (!resultA && resultB) {
|
||
const errorA = settledA.status === 'rejected' ? settledA.reason : 'unknown';
|
||
|
||
logger.warn(`Model ${modelA} failed, using ${modelB} only (degraded mode)`, {
|
||
failedModel: modelA,
|
||
error: errorA?.message || String(errorA),
|
||
successModelCost: resultB.cost
|
||
});
|
||
|
||
return {
|
||
resultA: null,
|
||
resultB,
|
||
degradedMode: true,
|
||
failedModel: modelA
|
||
};
|
||
}
|
||
|
||
// 情况3：模型B失败，使用模型A ⚠️
|
||
if (resultA && !resultB) {
|
||
const errorB = settledB.status === 'rejected' ? settledB.reason : 'unknown';
|
||
|
||
logger.warn(`Model ${modelB} failed, using ${modelA} only (degraded mode)`, {
|
||
failedModel: modelB,
|
||
error: errorB?.message || String(errorB),
|
||
successModelCost: resultA.cost
|
||
});
|
||
|
||
return {
|
||
resultA,
|
||
resultB: null,
|
||
degradedMode: true,
|
||
failedModel: modelB
|
||
};
|
||
}
|
||
|
||
// 情况4：双模型都成功 ✅
|
||
logger.info(
|
||
`Dual-model processing completed successfully, total cost: ¥${(resultA!.cost + resultB!.cost).toFixed(4)}`
|
||
);
|
||
|
||
return {
|
||
resultA,
|
||
resultB,
|
||
degradedMode: false
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 提取全文（Nougat优先策略）
|
||
*/
|
||
private async extractFullTextStructured(
|
||
pdfBuffer: Buffer,
|
||
filename: string
|
||
): Promise<{
|
||
fullTextMarkdown: string;
|
||
extractionMethod: 'nougat' | 'pymupdf';
|
||
structuredFormat: boolean;
|
||
}> {
|
||
logger.info('Extracting full-text with Nougat-first strategy...');
|
||
|
||
// Step 1: 检测语言（通过Python microservice）
|
||
// 注意：这里简化了，实际可能需要先用PyMuPDF提取少量文本检测语言
|
||
// 为了性能，我们直接尝试Nougat，失败则降级
|
||
|
||
// Step 2: 优先尝试Nougat（英文论文效果最好）
|
||
if (this.nougatOptions.preferNougat) {
|
||
try {
|
||
const nougatResult = await this.extractionClient.extractPdf(pdfBuffer, filename);
|
||
|
||
// 检查Nougat质量
|
||
if (
|
||
nougatResult.method === 'nougat' &&
|
||
(nougatResult.quality || 0) >= this.nougatOptions.nougatQualityThreshold
|
||
) {
|
||
logger.info('✅ Using Nougat extraction (structured Markdown)');
|
||
return {
|
||
fullTextMarkdown: nougatResult.text,
|
||
extractionMethod: 'nougat',
|
||
structuredFormat: true, // Nougat输出Markdown
|
||
};
|
||
} else {
|
||
logger.warn(
|
||
`⚠️ Nougat quality too low (${nougatResult.quality}), falling back to PyMuPDF`
|
||
);
|
||
}
|
||
} catch (error) {
|
||
logger.warn(`⚠️ Nougat extraction failed: ${(error as Error).message}, falling back to PyMuPDF`);
|
||
}
|
||
}
|
||
|
||
// Step 3: 降级使用PyMuPDF
|
||
logger.info('Using PyMuPDF extraction (plaintext)');
|
||
try {
|
||
const pymupdfResult = await this.extractionClient.extractPdf(pdfBuffer, filename);
|
||
|
||
return {
|
||
fullTextMarkdown: pymupdfResult.text,
|
||
extractionMethod: 'pymupdf',
|
||
structuredFormat: false, // PyMuPDF输出纯文本
|
||
};
|
||
} catch (error) {
|
||
// Step 4: 最后的fallback - 直接使用Buffer内容（测试模式）
|
||
logger.warn(`⚠️ PyMuPDF extraction also failed: ${(error as Error).message}, using buffer content directly`);
|
||
|
||
const textContent = pdfBuffer.toString('utf-8');
|
||
logger.info('✅ Using buffer content as plain text (test mode)');
|
||
|
||
return {
|
||
fullTextMarkdown: textContent,
|
||
extractionMethod: 'pymupdf', // 标记为pymupdf以保持一致性
|
||
structuredFormat: false,
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 调用LLM（带重试）
|
||
*/
|
||
private async callLLMWithRetry(
|
||
adapter: ILLMAdapter,
|
||
systemPrompt: string,
|
||
userPrompt: string,
|
||
_mode: LLM12FieldsMode,
|
||
maxRetries: number = 2
|
||
): Promise<string> {
|
||
let lastError: Error | null = null;
|
||
|
||
for (let attempt = 0; attempt <= maxRetries; attempt++) {
|
||
try {
|
||
logger.info(`LLM call attempt ${attempt + 1}/${maxRetries + 1}`);
|
||
|
||
const response = await adapter.chat(
|
||
[
|
||
{ role: 'system', content: systemPrompt },
|
||
{ role: 'user', content: userPrompt },
|
||
],
|
||
{
|
||
temperature: 0.1, // 低温度，提高一致性
|
||
maxTokens: 8000, // 足够输出12字段+处理日志
|
||
}
|
||
);
|
||
|
||
return response.content ?? '';
|
||
} catch (error) {
|
||
lastError = error as Error;
|
||
logger.error(`LLM call attempt ${attempt + 1} failed: ${(error as Error).message}`);
|
||
|
||
if (attempt < maxRetries) {
|
||
// 指数退避
|
||
const waitTime = Math.pow(2, attempt) * 1000;
|
||
logger.info(`Retrying in ${waitTime}ms...`);
|
||
await new Promise((resolve) => setTimeout(resolve, waitTime));
|
||
}
|
||
}
|
||
}
|
||
|
||
throw new Error(`LLM call failed after ${maxRetries + 1} attempts: ${lastError?.message}`);
|
||
}
|
||
|
||
/**
|
||
* 解析LLM响应（3层容错策略）
|
||
*
|
||
* Layer 1: 严格JSON解析
|
||
* Layer 2: JSON自动修复（jsonrepair）
|
||
* Layer 3: 提取代码块并解析
|
||
*/
|
||
private parseResponse(response: string): any {
|
||
// ========================================
|
||
// Layer 1: 严格JSON解析
|
||
// ========================================
|
||
try {
|
||
const result = JSON.parse(response);
|
||
logger.info('JSON parsed successfully (Layer 1: strict)');
|
||
return result;
|
||
} catch (layer1Error) {
|
||
logger.warn('Layer 1 failed: strict JSON parsing failed, trying Layer 2...');
|
||
}
|
||
|
||
// ========================================
|
||
// Layer 2: JSON自动修复
|
||
// ========================================
|
||
try {
|
||
const repaired = jsonrepair(response);
|
||
const result = JSON.parse(repaired);
|
||
|
||
logger.warn('JSON auto-repaired (Layer 2)', {
|
||
originalLength: response.length,
|
||
repairedLength: repaired.length,
|
||
message: 'LLM output had format issues, auto-repaired successfully'
|
||
});
|
||
|
||
return result;
|
||
} catch (layer2Error) {
|
||
logger.warn('Layer 2 failed: JSON repair failed, trying Layer 3...');
|
||
}
|
||
|
||
// ========================================
|
||
// Layer 3: 提取代码块
|
||
// ========================================
|
||
let layer3Error: Error | null = null;
|
||
try {
|
||
// 匹配多种代码块格式
|
||
const patterns = [
|
||
/```json\s*\n([\s\S]*?)\n```/, // ```json ... ```
|
||
/```\s*\n([\s\S]*?)\n```/, // ``` ... ```
|
||
/\{[\s\S]*\}/, // 直接匹配 {...}
|
||
];
|
||
|
||
for (const pattern of patterns) {
|
||
const match = response.match(pattern);
|
||
if (match) {
|
||
const extracted = match[1] || match[0];
|
||
|
||
// 先尝试严格解析提取的内容
|
||
try {
|
||
const result = JSON.parse(extracted);
|
||
logger.warn('JSON extracted from code block (Layer 3)', {
|
||
pattern: pattern.source,
|
||
message: 'LLM wrapped JSON in code block'
|
||
});
|
||
return result;
|
||
} catch {
|
||
// 尝试修复提取的内容
|
||
const repaired = jsonrepair(extracted);
|
||
const result = JSON.parse(repaired);
|
||
logger.warn('JSON extracted and repaired (Layer 3)', {
|
||
pattern: pattern.source,
|
||
message: 'LLM wrapped JSON in code block with format issues'
|
||
});
|
||
return result;
|
||
}
|
||
}
|
||
}
|
||
|
||
throw new Error('No valid JSON found in response');
|
||
} catch (error) {
|
||
layer3Error = error as Error;
|
||
logger.error('All 3 layers failed to parse JSON');
|
||
}
|
||
|
||
// ========================================
|
||
// 最终失败：记录详细错误
|
||
// ========================================
|
||
const err = layer3Error || new Error('Unknown parsing error');
|
||
logger.error('Failed to parse LLM response after all 3 layers', {
|
||
error: err.message,
|
||
responsePreview: response.substring(0, 500),
|
||
responseLength: response.length
|
||
});
|
||
|
||
throw new Error(
|
||
`Invalid JSON response from LLM after 3 parsing attempts: ${err.message}. ` +
|
||
`Please check logs for response preview.`
|
||
);
|
||
}
|
||
|
||
/**
|
||
* 生成缓存Key
|
||
*/
|
||
private generateCacheKey(
|
||
mode: LLM12FieldsMode,
|
||
model: string,
|
||
fullText: string,
|
||
picosContext: PICOSContext
|
||
): string {
|
||
const hash = crypto
|
||
.createHash('sha256')
|
||
.update(fullText + JSON.stringify(picosContext))
|
||
.digest('hex')
|
||
.substring(0, 16);
|
||
|
||
return `llm:${mode}:${model}:${hash}`;
|
||
}
|
||
|
||
/**
|
||
* 检查缓存
|
||
*/
|
||
private async checkCache(cacheKey: string): Promise<LLMResult | null> {
|
||
try {
|
||
const cached = await cache.get(cacheKey);
|
||
return cached ? JSON.parse(cached) : null;
|
||
} catch (error) {
|
||
logger.warn(`Cache check failed: ${(error as Error).message}`);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 缓存结果
|
||
*/
|
||
private async cacheResult(cacheKey: string, result: LLMResult): Promise<void> {
|
||
try {
|
||
// 缓存1小时
|
||
await cache.set(cacheKey, JSON.stringify(result), 3600);
|
||
logger.info(`Result cached with key: ${cacheKey}`);
|
||
} catch (error) {
|
||
logger.warn(`Cache set failed: ${(error as Error).message}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 计算成本（人民币）
|
||
*/
|
||
private calculateCost(model: string, tokenUsage: number): number {
|
||
// 成本表（人民币/1K tokens）
|
||
const COST_TABLE: Record<string, number> = {
|
||
'deepseek-v3': 0.001, // ¥0.001/1K tokens
|
||
'qwen-max': 0.004, // ¥0.004/1K tokens
|
||
'qwen-plus': 0.002, // ¥0.002/1K tokens
|
||
'qwen-turbo': 0.0008, // ¥0.0008/1K tokens
|
||
'gpt-4o': 0.03, // $0.005/1K tokens ≈ ¥0.03/1K tokens
|
||
'claude-3.5-sonnet': 0.02, // $0.003/1K tokens ≈ ¥0.02/1K tokens
|
||
};
|
||
|
||
const costPerK = COST_TABLE[model] || 0.01; // 默认值
|
||
return (tokenUsage / 1000) * costPerK;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 创建LLM12FieldsService单例
|
||
*/
|
||
export const llm12FieldsService = new LLM12FieldsService();
|
||
|