@louloulinx/metagpt 0.1.3

package/src/provider/vercel-llm.ts

@@ -0,0 +1,314 @@
+/**
+ * 使用示例:
+ * 
+ * ```typescript
+ * // 使用 qwen-plus 模型示例
+ * import { VercelLLMProvider } from './vercel-llm';
+ * import { generateText } from 'ai';
+ * 
+ * async function main() {
+ *   // 初始化 Qwen 提供商
+ *   const qwenProvider = new VercelLLMProvider({
+ *     providerType: 'qwen',
+ *     apiKey: process.env.DASHSCOPE_API_KEY || 'your-qwen-api-key',
+ *     model: 'qwen-plus',
+ *     baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1', // 可选，自定义URL
+ *     extraConfig: {
+ *       qwenOptions: {
+ *         // 其他Qwen配置选项
+ *       }
+ *     }
+ *   });
+ *   
+ *   // 使用 qwen-plus 生成文本
+ *   const result = await qwenProvider.generate(
+ *     '写一个4人份的素食千层面食谱。',
+ *     { temperature: 0.7 }
+ *   );
+ *   
+ *   console.log(result);
+ *   
+ *   // 或者直接使用 Vercel AI SDK
+ *   // 需要先安装: bun add qwen-ai-provider
+ *   // import { createQwen } from 'qwen-ai-provider';
+ *   // const qwen = createQwen({ baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1' });
+ *   // const { text } = await generateText({
+ *   //   model: qwen('qwen-plus'),
+ *   //   prompt: '写一个4人份的素食千层面食谱。',
+ *   // });
+ *   // console.log(text);
+ * }
+ * ```
+ */
+
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { z } from 'zod';
+import type { LLMConfig, LLMProvider } from '../types/llm';
+
+/**
+ * 支持的模型提供商类型
+ */
+export type ModelProviderType = 'openai' | 'qwen' | 'anthropic' | 'mistral' | 'google' | 'custom';
+
+/**
+ * 模型提供商配置
+ */
+export const ModelProviderConfigSchema = z.object({
+  providerType: z.enum(['openai', 'qwen', 'anthropic', 'mistral', 'google', 'custom']).default('openai'),
+  apiKey: z.string(),
+  baseURL: z.string().optional(),
+  model: z.string().optional(),
+  extraConfig: z.record(z.any()).optional(),
+});
+
+export type ModelProviderConfig = z.infer<typeof ModelProviderConfigSchema>;
+
+/**
+ * 基于 Vercel AI SDK 的通用 LLM 提供商实现
+ */
+export class VercelLLMProvider implements LLMProvider {
+  private config: ModelProviderConfig;
+  private providerFunctions: Record<ModelProviderType, any> = {
+    openai: openai,
+    qwen: null,
+    anthropic: null,
+    mistral: null,
+    google: null,
+    custom: null,
+  };
+
+  constructor(config: ModelProviderConfig) {
+    this.config = ModelProviderConfigSchema.parse(config);
+    this.setupEnvironment();
+    this.loadProviderModules();
+  }
+
+  /**
+   * 设置环境变量
+   */
+  private setupEnvironment(): void {
+    // 根据不同提供商设置对应的环境变量
+    switch (this.config.providerType) {
+      case 'openai':
+        if (process.env.OPENAI_API_KEY !== this.config.apiKey) {
+          process.env.OPENAI_API_KEY = this.config.apiKey;
+        }
+        if (this.config.baseURL) {
+          process.env.OPENAI_API_HOST = this.config.baseURL;
+        }
+        break;
+      case 'qwen':
+        if (process.env.DASHSCOPE_API_KEY !== this.config.apiKey) {
+          process.env.DASHSCOPE_API_KEY = this.config.apiKey;
+        }
+        // 注意: baseURL会在createQwen时设置，不需要设置环境变量
+        break;
+      // 其他提供商的环境变量设置...
+      default:
+        // 自定义提供商可能需要在extraConfig中指定环境变量
+        if (this.config.extraConfig?.environmentVars) {
+          const envVars = this.config.extraConfig.environmentVars as Record<string, string>;
+          for (const [key, value] of Object.entries(envVars)) {
+            process.env[key] = value;
+          }
+        }
+    }
+  }
+
+  /**
+   * 动态加载提供商模块
+   */
+  private loadProviderModules(): void {
+    try {
+      // 根据配置动态加载需要的提供商模块
+      switch (this.config.providerType) {
+        case 'qwen':
+          // 动态导入提供商，避免在不需要时加载所有依赖
+          import('qwen-ai-provider').then(module => {
+            // 使用createQwen创建自定义配置的qwen提供商
+            const createQwen = module.createQwen;
+            if (createQwen) {
+              // 准备Qwen配置选项
+              const qwenOptions: Record<string, any> = {
+                ...(this.config.extraConfig?.qwenOptions || {})
+              };
+              
+              // 如果提供了baseURL，添加到配置中
+              if (this.config.baseURL) {
+                qwenOptions.baseURL = this.config.baseURL;
+              }
+              
+              // 创建并存储qwen提供商函数
+              this.providerFunctions.qwen = createQwen(qwenOptions);
+            } else {
+              // 回退到传统方式
+              this.providerFunctions.qwen = module.qwen;
+              console.warn('Using legacy qwen provider. For more customization options, upgrade to newer qwen-ai-provider with createQwen support.');
+            }
+          }).catch(err => {
+            console.warn(`Failed to load qwen provider: ${err.message}. Make sure 'qwen-ai-provider' is installed.`);
+          });
+          break;
+        case 'anthropic':
+          import('@ai-sdk/anthropic').then(module => {
+            this.providerFunctions.anthropic = module.anthropic;
+          }).catch(err => {
+            console.warn(`Failed to load anthropic provider: ${err.message}. Make sure '@ai-sdk/anthropic' is installed.`);
+          });
+          break;
+        case 'mistral':
+          import('@ai-sdk/mistral').then(module => {
+            this.providerFunctions.mistral = module.mistral;
+          }).catch(err => {
+            console.warn(`Failed to load mistral provider: ${err.message}. Make sure '@ai-sdk/mistral' is installed.`);
+          });
+          break;
+        case 'google':
+          import('@ai-sdk/google').then(module => {
+            this.providerFunctions.google = module.google;
+          }).catch(err => {
+            console.warn(`Failed to load google provider: ${err.message}. Make sure '@ai-sdk/google' is installed.`);
+          });
+          break;
+        case 'custom':
+          // 自定义提供商需要在extraConfig中提供modelFunction
+          if (this.config.extraConfig?.modelFunction) {
+            this.providerFunctions.custom = this.config.extraConfig.modelFunction;
+          } else {
+            console.warn('Custom provider specified but no modelFunction provided in extraConfig');
+          }
+          break;
+      }
+    } catch (error) {
+      console.error('Error loading provider modules:', error);
+    }
+  }
+
+  /**
+   * 获取当前提供商的模型函数
+   * @param modelName 模型名称
+   * @returns 模型函数调用结果
+   */
+  private getModelFunction(modelName?: string): any {
+    const provider = this.providerFunctions[this.config.providerType];
+    if (!provider) {
+      throw new Error(`Provider ${this.config.providerType} not loaded or not available`);
+    }
+    
+    return provider(modelName || this.config.model || this.getDefaultModel());
+  }
+
+  /**
+   * 获取提供商的默认模型
+   */
+  private getDefaultModel(): string {
+    switch (this.config.providerType) {
+      case 'openai':
+        return 'gpt-3.5-turbo';
+      case 'qwen':
+        return 'qwen-plus';
+      case 'anthropic':
+        return 'claude-3-sonnet-20240229';
+      case 'mistral':
+        return 'mistral-large-latest';
+      case 'google':
+        return 'gemini-pro';
+      case 'custom':
+        return this.config.extraConfig?.defaultModel || 'default-model';
+      default:
+        return 'gpt-3.5-turbo';
+    }
+  }
+
+  /**
+   * 生成文本
+   * @param prompt 提示词
+   * @param config 配置选项
+   * @returns 生成的文本
+   */
+  async generate(prompt: string, config?: Partial<LLMConfig>): Promise<string> {
+    try {
+      // 确保提供商模块已加载完成
+      if (this.config.providerType !== 'openai' && !this.providerFunctions[this.config.providerType]) {
+        await new Promise(resolve => setTimeout(resolve, 1000)); // 等待动态导入完成
+      }
+
+      // @ts-ignore - Type compatibility issue between different versions of AI SDK
+      const model = this.getModelFunction(config?.model);
+      
+      const result = await generateText({
+        model,
+        prompt,
+        temperature: config?.temperature,
+        maxTokens: config?.maxTokens,
+        topP: config?.topP,
+        frequencyPenalty: config?.frequencyPenalty,
+        presencePenalty: config?.presencePenalty,
+        ...this.config.extraConfig?.generateOptions,
+      });
+
+      return result.text;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * 生成文本流
+   * @param prompt 提示词
+   * @param config 配置选项
+   * @returns 生成的文本流
+   */
+  async *generateStream(prompt: string, config?: Partial<LLMConfig>): AsyncGenerator<string> {
+    try {
+      // 使用generate方法获取完整响应，然后模拟流式响应
+      // 由于当前streamText在TypeScript类型中存在兼容性问题
+      const result = await this.generate(prompt, config);
+      
+      // 将完整的响应分成字符并逐个返回，模拟流式响应
+      const characters = result.split('');
+      for (const char of characters) {
+        yield char;
+        // 添加小延迟以模拟真实的流式响应
+        await new Promise(resolve => setTimeout(resolve, 5));
+      }
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * 嵌入文本
+   * @param text 要嵌入的文本
+   * @returns 嵌入向量
+   */
+  async embed(text: string): Promise<number[]> {
+    try {
+      // Note: For embeddings in the newer Vercel AI SDK, we'd typically use:
+      // import { generateEmbedding } from 'ai/embedding';
+      
+      // This is a temporary implementation - in a real application,
+      // you would implement this based on the AI SDK's embedding functionality
+      console.warn(`Embedding functionality not yet implemented for ${this.config.providerType} provider`);
+      
+      // Placeholder implementation
+      return new Array(1536).fill(0).map(() => Math.random());
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * 错误处理
+   * @param error 原始错误
+   * @returns 标准化的错误
+   */
+  private handleError(error: unknown): Error {
+    console.error(`${this.config.providerType} provider error:`, error);
+    if (error instanceof Error) {
+      return error;
+    }
+    return new Error(`Unknown ${this.config.providerType} provider error`);
+  }
+} 

package/src/rag/base-rag.ts

@@ -0,0 +1,194 @@
+import { QdrantClient } from '@qdrant/js-client-rest';
+import type { RAGConfig, RAGSystem, Chunk, SearchResult } from '../types/rag';
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * 基础RAG系统实现
+ */
+export class BaseRAG implements RAGSystem {
+  protected config: RAGConfig;
+  protected llm: any; // LLMProvider
+  protected vectorStore: QdrantClient;
+
+  constructor(config: RAGConfig) {
+    this.config = config;
+    this.llm = config.llm;
+    this.vectorStore = new QdrantClient({
+      url: config.vectorStore.url,
+      apiKey: config.vectorStore.apiKey,
+    });
+  }
+
+  /**
+   * 添加文档
+   * @param content 文档内容
+   * @param metadata 文档元数据
+   */
+  public async addDocument(
+    content: string,
+    metadata: Record<string, any> = {}
+  ): Promise<Chunk[]> {
+    // 分块
+    const chunks = await this.chunkText(content);
+
+    // 生成嵌入向量
+    const embeddings = await Promise.all(
+      chunks.map(chunk => this.llm.generateEmbedding(chunk))
+    );
+
+    // 创建文档块
+    const chunkObjects = chunks.map((chunk, i) => ({
+      id: uuidv4(),
+      content: chunk,
+      embedding: embeddings[i],
+      metadata: {
+        ...metadata,
+        timestamp: Date.now(),
+      },
+    }));
+
+    // 存储向量
+    await this.vectorStore.upsert(this.config.vectorStore.collectionName, {
+      points: chunkObjects.map(chunk => ({
+        id: chunk.id,
+        vector: chunk.embedding,
+        payload: {
+          content: chunk.content,
+          metadata: chunk.metadata,
+        },
+      })),
+    });
+
+    return chunkObjects;
+  }
+
+  /**
+   * 删除文档块
+   * @param ids 块ID列表
+   */
+  public async deleteChunks(ids: string[]): Promise<void> {
+    await this.vectorStore.delete(this.config.vectorStore.collectionName, {
+      points: ids,
+    });
+  }
+
+  /**
+   * 更新文档块
+   * @param chunk 文档块
+   */
+  public async updateChunk(chunk: Chunk): Promise<void> {
+    await this.vectorStore.upsert(this.config.vectorStore.collectionName, {
+      points: [
+        {
+          id: chunk.id,
+          vector: chunk.embedding,
+          payload: {
+            content: chunk.content,
+            metadata: chunk.metadata,
+          },
+        },
+      ],
+    });
+  }
+
+  /**
+   * 搜索相关文档
+   * @param query 查询文本
+   * @param topK 返回结果数量
+   */
+  public async search(
+    query: string,
+    topK: number = this.config.topK
+  ): Promise<SearchResult[]> {
+    // 生成查询向量
+    const queryEmbedding = await this.llm.generateEmbedding(query);
+
+    // 搜索相似向量
+    const results = await this.vectorStore.search(
+      this.config.vectorStore.collectionName,
+      {
+        vector: queryEmbedding,
+        limit: topK,
+        with_payload: true,
+      }
+    );
+
+    // 转换结果格式
+    return results
+      .filter(result => result.payload && typeof result.payload === 'object')
+      .map(result => ({
+        chunk: {
+          id: result.id as string,
+          content: result.payload!.content as string,
+          embedding: queryEmbedding as number[],
+          metadata: result.payload!.metadata as Record<string, any>,
+        },
+        score: result.score,
+        metadata: result.payload!.metadata as Record<string, any>,
+      }));
+  }
+
+  /**
+   * 生成回答
+   * @param query 查询文本
+   */
+  public async generate(query: string): Promise<string> {
+    // 搜索相关文档
+    const results = await this.search(query);
+    if (results.length === 0) {
+      return 'No relevant information found.';
+    }
+
+    // 构建提示词
+    const prompt = this.buildPrompt(query, results);
+
+    // 生成回答
+    return await this.llm.generate(prompt);
+  }
+
+  /**
+   * 分块文本
+   * @param text 文本内容
+   */
+  protected async chunkText(text: string): Promise<string[]> {
+    // 简单按长度分块，子类可以重写此方法实现更智能的分块
+    const chunks: string[] = [];
+    let currentChunk = '';
+
+    const words = text.split(/\s+/);
+    for (const word of words) {
+      if (
+        currentChunk.length + word.length + 1 <= this.config.chunkSize ||
+        currentChunk.length === 0
+      ) {
+        currentChunk = currentChunk ? `${currentChunk} ${word}` : word;
+      } else {
+        chunks.push(currentChunk);
+        currentChunk = word;
+      }
+    }
+
+    if (currentChunk) {
+      chunks.push(currentChunk);
+    }
+
+    return chunks;
+  }
+
+  /**
+   * 构建提示词
+   * @param query 查询文本
+   * @param results 搜索结果
+   */
+  protected buildPrompt(query: string, results: SearchResult[]): string {
+    return `
+Based on the following passages, please answer the question.
+
+Question: ${query}
+
+Relevant passages:
+${results.map(r => r.chunk.content).join('\n\n')}
+
+Answer:`.trim();
+  }
+} 

package/src/rag/document-qa.ts

@@ -0,0 +1,102 @@
+import { BaseRAG } from './base-rag';
+import type { RAGConfig, SearchResult } from '../types/rag';
+
+/**
+ * 文档问答系统
+ * 基于RAG的文档智能问答
+ */
+export class DocumentQA extends BaseRAG {
+  constructor(config: RAGConfig) {
+    super(config);
+  }
+
+  /**
+   * 生成带引用的回答
+   * @param query 查询文本
+   */
+  public async generateWithCitations(
+    query: string
+  ): Promise<{ answer: string; citations: SearchResult[] }> {
+    // 搜索相关文档
+    const results = await this.search(query);
+    if (results.length === 0) {
+      return {
+        answer: 'No relevant information found.',
+        citations: [],
+      };
+    }
+
+    // 构建提示词
+    const prompt = this.buildPrompt(query, results);
+
+    // 生成回答
+    const answer = await this.llm.generate(prompt);
+
+    return {
+      answer,
+      citations: results,
+    };
+  }
+
+  /**
+   * 智能分块
+   * @param text 文本内容
+   */
+  protected async chunkText(text: string): Promise<string[]> {
+    // 按段落分块
+    const paragraphs = text
+      .split(/\n\s*\n/)
+      .map(p => p.trim())
+      .filter(Boolean);
+
+    const chunks: string[] = [];
+    let currentChunk = '';
+
+    for (const paragraph of paragraphs) {
+      // 如果当前块加上新段落不超过最大大小，则合并
+      if (
+        currentChunk.length + paragraph.length + 1 <= this.config.chunkSize ||
+        currentChunk.length === 0
+      ) {
+        currentChunk = currentChunk
+          ? `${currentChunk}\n\n${paragraph}`
+          : paragraph;
+      } else {
+        // 否则保存当前块并开始新块
+        chunks.push(currentChunk);
+        currentChunk = paragraph;
+      }
+    }
+
+    // 添加最后一个块
+    if (currentChunk) {
+      chunks.push(currentChunk);
+    }
+
+    return chunks;
+  }
+
+  /**
+   * 构建提示词
+   * @param query 查询文本
+   * @param results 搜索结果
+   */
+  protected buildPrompt(query: string, results: SearchResult[]): string {
+    return `
+You are a helpful assistant that provides accurate answers based on the given reference passages.
+Please answer the question and cite the relevant passages using [1], [2], etc.
+
+Question: ${query}
+
+Reference passages:
+${results.map((r, i) => `[${i + 1}] ${r.chunk.content}`).join('\n\n')}
+
+Instructions:
+1. Use information from the reference passages to answer the question
+2. Cite sources using [1], [2], etc.
+3. If the passages don't contain enough information, say so
+4. Keep the answer concise and relevant
+
+Answer:`.trim();
+  }
+}