iflow-mcp_hanw39_reasoning-bank-mcp 0.2.0__py3-none-any.whl

src/default_config.yaml

@@ -0,0 +1,121 @@
+# LLM 配置
+llm:
+  provider: "dashscope"  # dashscope | openai | anthropic
+
+  # DashScope (通义千问) 配置
+  dashscope:
+    api_key: "${DASHSCOPE_API_KEY}"
+    base_url: "https://dashscope.aliyuncs.com/compatible-mode/v1"
+    chat_model: "qwen-turbo"  # qwen-turbo | qwen-plus | qwen-max
+    temperature: 0.7
+    max_tokens: 4096
+
+  # OpenAI 配置
+  openai:
+    api_key: "${OPENAI_API_KEY?}"  # 可选，未设置时为空
+    base_url: "https://api.openai.com/v1"
+    chat_model: "gpt-4o-mini"
+    temperature: 0.7
+    max_tokens: 4096
+
+  # Anthropic 配置
+  anthropic:
+    api_key: "${ANTHROPIC_API_KEY?}"  # 可选，未设置时为空
+    chat_model: "claude-3-5-sonnet-20241022"
+    temperature: 0.7
+    max_tokens: 4096
+
+# Embedding 配置
+embedding:
+  provider: "dashscope"  # dashscope | openai
+
+  dashscope:
+    api_key: "${DASHSCOPE_API_KEY}"
+    base_url: "https://dashscope.aliyuncs.com/compatible-mode/v1"
+    model: "text-embedding-v3"
+
+  openai:
+    api_key: "${OPENAI_API_KEY?}"  # 可选，未设置时为空
+    base_url: "https://api.openai.com/v1"
+    model: "text-embedding-3-small"
+
+# 检索配置
+retrieval:
+  strategy: "hybrid"  # cosine | hybrid | llm_assisted
+  default_top_k: 1
+  max_top_k: 10
+  min_score_threshold: 0.85  # 最小相关度阈值，低于此值的记忆不会被返回
+
+  # Hybrid 策略配置
+  hybrid:
+    weights:
+      semantic: 0.6      # 语义相似度权重
+      confidence: 0.2    # 置信度权重
+      success: 0.15      # 成功偏好权重
+      recency: 0.05      # 时效性权重
+    time_decay_halflife: 30  # 时间衰减半衰期（天）
+
+# 存储配置
+storage:
+  backend: "json"  # json | sqlite | chroma
+
+  json:
+    memories_path: "~/.reasoningbank/data/memories.json"
+    embeddings_path: "~/.reasoningbank/data/embeddings.json"
+    archived_path: "~/.reasoningbank/data/archived_memories.json"
+#    memories_path: "/Users/hanw/data/memories.json"
+#    embeddings_path: "/Users/hanw/data/embeddings.json"
+
+  sqlite:
+    db_path: "~/.reasoningbank/data/reasoning_bank.db"
+
+# 记忆提取配置
+extraction:
+  max_memories_per_trajectory: 3  # 每个轨迹最多提取记忆数
+  judge_temperature: 0.0          # 判断轨迹成功/失败的温度
+  extract_temperature: 1.0        # 提取记忆的温度
+  async_by_default: true          # 默认异步处理
+
+# MCP 服务器配置
+server:
+  name: "reasoning-bank"
+  version: "0.1.0"
+  log_level: "INFO"  # DEBUG | INFO | WARNING | ERROR
+
+# 记忆管理配置
+memory_manager:
+  enabled: true  # 是否启用记忆管理器
+
+  # 去重配置
+  deduplication:
+    strategy: "semantic"  # semantic (语义去重)
+    on_extraction: true   # 在提取时实时去重
+
+    # 语义去重配置
+    semantic:
+      threshold: 0.90           # 相似度阈值（0-1）
+      top_k_check: 1            # 检查最相似的前K条记忆
+
+  # 合并配置
+  merge:
+    strategy: "llm"  # llm | voting | template
+    auto_execute: true  # 自动执行合并（后台）
+
+    # 触发条件
+    trigger:
+      min_similar_count: 3         # 最少相似记忆数
+      similarity_threshold: 0.85   # 相似度阈值
+
+    # LLM合并配置
+    llm:
+      temperature: 0.7
+
+    # Voting合并配置
+    voting:
+      min_group_size: 2
+
+    # 原记忆处理
+    original_handling: "archive"  # archive | delete | mark
+    archive:
+      keep_embeddings: false  # 归档时是否保留embedding
+

src/initializers/__init__.py

@@ -0,0 +1,50 @@
+"""组件初始化器模块
+
+提供自动化的组件初始化和依赖管理功能。
+
+使用方式：
+    from initializers import InitializerRegistry
+    from initializers import (
+        StorageInitializer,
+        LLMInitializer,
+        EmbeddingInitializer,
+        RetrievalInitializer,
+        MemoryManagerInitializer,
+        ToolsInitializer
+    )
+
+    # 创建注册表
+    registry = InitializerRegistry()
+
+    # 自动注册所有初始化器
+    registry.auto_register([
+        StorageInitializer,
+        LLMInitializer,
+        EmbeddingInitializer,
+        RetrievalInitializer,
+        MemoryManagerInitializer,
+        ToolsInitializer
+    ], config)
+
+    # 自动初始化所有组件
+    components = await registry.initialize_all(config)
+"""
+
+from .base import ComponentInitializer, InitializerRegistry
+from .storage_initializer import StorageInitializer
+from .llm_initializer import LLMInitializer
+from .embedding_initializer import EmbeddingInitializer
+from .retrieval_initializer import RetrievalInitializer
+from .memory_manager_initializer import MemoryManagerInitializer
+from .tools_initializer import ToolsInitializer
+
+__all__ = [
+    "ComponentInitializer",
+    "InitializerRegistry",
+    "StorageInitializer",
+    "LLMInitializer",
+    "EmbeddingInitializer",
+    "RetrievalInitializer",
+    "MemoryManagerInitializer",
+    "ToolsInitializer",
+]

src/initializers/base.py

@@ -0,0 +1,196 @@
+"""组件初始化器基类"""
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Type
+
+logger = logging.getLogger("reasoning-bank-mcp")
+
+
+class ComponentInitializer(ABC):
+    """组件初始化器基类
+
+    每个组件（如 Storage、LLM、Embedding 等）都应该实现自己的初始化器。
+    初始化器负责：
+    1. 声明组件名称
+    2. 声明依赖的其他组件
+    3. 从配置中读取必要的配置项
+    4. 执行初始化逻辑
+    """
+
+    def __init__(self, config: Any):
+        """初始化器构造函数
+
+        Args:
+            config: 配置对象
+        """
+        self.config = config
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """组件名称，用于标识和日志输出"""
+        pass
+
+    @property
+    def dependencies(self) -> List[str]:
+        """依赖的其他组件名称列表，确保按依赖顺序初始化"""
+        return []
+
+    @property
+    def enabled(self) -> bool:
+        """组件是否启用，默认启用。可被子类重写以支持条件初始化"""
+        return True
+
+    @abstractmethod
+    async def initialize(self, context: Dict[str, Any]) -> Any:
+        """执行初始化逻辑
+
+        Args:
+            context: 初始化上下文，包含 config 和已初始化的其他组件
+
+        Returns:
+            初始化后的组件实例
+        """
+        pass
+
+    def _get_config(self, context: Dict[str, Any]) -> Any:
+        """从上下文获取配置对象"""
+        return context.get("config")
+
+    def _get_component(self, context: Dict[str, Any], name: str) -> Optional[Any]:
+        """从上下文获取已初始化的组件"""
+        return context.get(name)
+
+
+class InitializerRegistry:
+    """初始化器注册表
+
+    负责：
+    1. 注册所有组件初始化器
+    2. 解析依赖关系
+    3. 按正确顺序执行初始化
+    4. 管理初始化上下文
+    """
+
+    def __init__(self):
+        self._initializers: Dict[str, ComponentInitializer] = {}
+        self._initialized_components: Dict[str, Any] = {}
+
+    def register(self, initializer: ComponentInitializer):
+        """注册一个初始化器"""
+        self._initializers[initializer.name] = initializer
+        logger.debug(f"已注册初始化器: {initializer.name}")
+
+    def register_many(self, initializers: List[ComponentInitializer]):
+        """批量注册初始化器"""
+        for initializer in initializers:
+            self.register(initializer)
+
+    def auto_register(self, initializer_classes: List[Type[ComponentInitializer]], config: Any):
+        """自动注册初始化器类
+
+        Args:
+            initializer_classes: 初始化器类列表
+            config: 配置对象，将传递给初始化器构造函数
+        """
+        for initializer_class in initializer_classes:
+            initializer = initializer_class(config)
+            if initializer.enabled:
+                self.register(initializer)
+            else:
+                logger.info(f"跳过禁用的组件: {initializer.name}")
+
+    async def initialize_all(self, config: Any) -> Dict[str, Any]:
+        """按依赖顺序初始化所有组件
+
+        Args:
+            config: 配置对象
+
+        Returns:
+            所有已初始化的组件字典
+        """
+        # 初始化上下文
+        context = {
+            "config": config
+        }
+
+        # 拓扑排序，解析依赖顺序
+        sorted_names = self._topological_sort()
+
+        # 按顺序初始化
+        for name in sorted_names:
+            initializer = self._initializers[name]
+
+            logger.info(f"正在初始化 {initializer.name}...")
+
+            try:
+                # 执行初始化
+                component = await initializer.initialize(context)
+
+                # 保存到上下文
+                context[name] = component
+                self._initialized_components[name] = component
+
+                logger.info(f"✓ {initializer.name} 初始化完成")
+
+            except Exception as e:
+                logger.error(f"✗ {initializer.name} 初始化失败: {e}")
+                raise
+
+        return self._initialized_components
+
+    def _topological_sort(self) -> List[str]:
+        """拓扑排序，解析依赖关系
+
+        Returns:
+            排序后的组件名称列表
+
+        Raises:
+            ValueError: 如果存在循环依赖
+        """
+        # 构建依赖图和入度表
+        graph = {}
+        in_degree = {}
+
+        # 初始化图结构
+        for name, initializer in self._initializers.items():
+            graph[name] = initializer.dependencies
+            in_degree[name] = 0
+
+        # 计算入度
+        for name, deps in graph.items():
+            for dep in deps:
+                if dep not in self._initializers:
+                    raise ValueError(f"组件 '{name}' 依赖的组件 '{dep}' 未注册")
+                in_degree[name] = in_degree.get(name, 0) + 1
+
+        # Kahn 算法进行拓扑排序
+        queue = [name for name, degree in in_degree.items() if degree == 0]
+        result = []
+
+        while queue:
+            # 选择入度为0的节点
+            current = queue.pop(0)
+            result.append(current)
+
+            # 减少依赖当前节点的其他节点的入度
+            for name in self._initializers.keys():
+                if current in graph[name]:
+                    in_degree[name] -= 1
+                    if in_degree[name] == 0:
+                        queue.append(name)
+
+        # 检查是否存在循环依赖
+        if len(result) != len(self._initializers):
+            raise ValueError("存在循环依赖，无法初始化")
+
+        return result
+
+    def get_component(self, name: str) -> Optional[Any]:
+        """获取已初始化的组件"""
+        return self._initialized_components.get(name)
+
+    def get_all_components(self) -> Dict[str, Any]:
+        """获取所有已初始化的组件"""
+        return self._initialized_components.copy()

src/initializers/embedding_initializer.py

@@ -0,0 +1,22 @@
+"""Embedding Provider 初始化器"""
+
+from typing import Any, Dict
+from .base import ComponentInitializer
+from ..llm import EmbeddingFactory
+
+
+class EmbeddingInitializer(ComponentInitializer):
+    """Embedding Provider 初始化器"""
+
+    @property
+    def name(self) -> str:
+        return "embedding"
+
+    @property
+    def dependencies(self):
+        return []  # 无依赖
+
+    async def initialize(self, context: Dict[str, Any]) -> Any:
+        """初始化 Embedding Provider"""
+        embedding_config = self.config.get_embedding_config()
+        return EmbeddingFactory.create(embedding_config)

src/initializers/llm_initializer.py

@@ -0,0 +1,22 @@
+"""LLM Provider 初始化器"""
+
+from typing import Any, Dict
+from .base import ComponentInitializer
+from ..llm import LLMFactory
+
+
+class LLMInitializer(ComponentInitializer):
+    """LLM Provider 初始化器"""
+
+    @property
+    def name(self) -> str:
+        return "llm"
+
+    @property
+    def dependencies(self):
+        return []  # 无依赖
+
+    async def initialize(self, context: Dict[str, Any]) -> Any:
+        """初始化 LLM Provider"""
+        llm_config = self.config.get_llm_config()
+        return LLMFactory.create(llm_config)

src/initializers/memory_manager_initializer.py

@@ -0,0 +1,55 @@
+"""记忆管理器初始化器"""
+
+import logging
+from typing import Any, Dict
+from .base import ComponentInitializer
+from ..services import MemoryManager
+from ..deduplication import DeduplicationFactory
+from ..merge import MergeFactory
+
+logger = logging.getLogger("reasoning-bank-mcp")
+
+
+class MemoryManagerInitializer(ComponentInitializer):
+    """记忆管理器初始化器"""
+
+    @property
+    def name(self) -> str:
+        return "memory_manager"
+
+    @property
+    def dependencies(self):
+        return ["storage", "llm", "embedding"]  # 依赖这三个组件
+
+    @property
+    def enabled(self) -> bool:
+        """根据配置判断是否启用"""
+        return self.config.get("memory_manager", "enabled", default=True)
+
+    async def initialize(self, context: Dict[str, Any]) -> Any:
+        """初始化记忆管理器"""
+        # 获取依赖组件
+        storage = self._get_component(context, "storage")
+        llm = self._get_component(context, "llm")
+        embedding = self._get_component(context, "embedding")
+
+        # 创建去重策略（传递 Config 对象）
+        dedup_strategy = DeduplicationFactory.create(self.config)
+
+        # 创建合并策略（传递 Config 对象）
+        merge_strategy = MergeFactory.create(self.config)
+
+        # 创建记忆管理器
+        memory_manager = MemoryManager(
+            storage_backend=storage,
+            dedup_strategy=dedup_strategy,
+            merge_strategy=merge_strategy,
+            embedding_provider=embedding,
+            llm_provider=llm,
+            config=self.config.all
+        )
+
+        logger.info(f"  - 去重策略: {dedup_strategy.name}")
+        logger.info(f"  - 合并策略: {merge_strategy.name}")
+
+        return memory_manager

src/initializers/retrieval_initializer.py

@@ -0,0 +1,32 @@
+"""检索策略初始化器"""
+
+from typing import Any, Dict
+from .base import ComponentInitializer
+from ..retrieval import RetrievalFactory
+
+
+class RetrievalInitializer(ComponentInitializer):
+    """检索策略初始化器"""
+
+    @property
+    def name(self) -> str:
+        return "retrieval"
+
+    @property
+    def dependencies(self):
+        return ["storage"]  # 依赖 storage，因为需要注入到 storage 中
+
+    async def initialize(self, context: Dict[str, Any]) -> Any:
+        """初始化检索策略"""
+        retrieval_config = self.config.get_retrieval_config()
+        retrieval = RetrievalFactory.create(
+            retrieval_config["strategy"],
+            retrieval_config.get("strategy_config")
+        )
+
+        # 注入 retrieval_strategy 到 storage（用于语义去重）
+        storage = self._get_component(context, "storage")
+        if storage:
+            storage.retrieval_strategy = retrieval
+
+        return retrieval

src/initializers/storage_initializer.py

@@ -0,0 +1,22 @@
+"""存储后端初始化器"""
+
+from typing import Any, Dict
+from .base import ComponentInitializer
+from ..storage import StorageFactory
+
+
+class StorageInitializer(ComponentInitializer):
+    """存储后端初始化器"""
+
+    @property
+    def name(self) -> str:
+        return "storage"
+
+    @property
+    def dependencies(self):
+        return []  # 无依赖
+
+    async def initialize(self, context: Dict[str, Any]) -> Any:
+        """初始化存储后端"""
+        storage_config = self.config.get_storage_config()
+        return StorageFactory.create(storage_config)

src/initializers/tools_initializer.py

@@ -0,0 +1,48 @@
+"""MCP 工具初始化器"""
+
+from typing import Any, Dict
+from .base import ComponentInitializer
+from ..tools import RetrieveMemoryTool, ExtractMemoryTool
+
+
+class ToolsInitializer(ComponentInitializer):
+    """MCP 工具初始化器"""
+
+    @property
+    def name(self) -> str:
+        return "tools"
+
+    @property
+    def dependencies(self):
+        # tools 依赖所有其他组件
+        return ["storage", "llm", "embedding", "retrieval", "memory_manager"]
+
+    async def initialize(self, context: Dict[str, Any]) -> Any:
+        """初始化 MCP 工具"""
+        # 获取依赖组件
+        storage = self._get_component(context, "storage")
+        llm = self._get_component(context, "llm")
+        embedding = self._get_component(context, "embedding")
+        retrieval = self._get_component(context, "retrieval")
+        memory_manager = self._get_component(context, "memory_manager")
+
+        # 创建工具实例
+        retrieve_tool = RetrieveMemoryTool(
+            self.config,
+            storage,
+            embedding,
+            retrieval
+        )
+
+        extract_tool = ExtractMemoryTool(
+            self.config,
+            storage,
+            llm,
+            embedding,
+            memory_manager
+        )
+
+        return {
+            "retrieve_tool": retrieve_tool,
+            "extract_tool": extract_tool
+        }

src/llm/__init__.py

@@ -0,0 +1,10 @@
+"""LLM 模块"""
+from .base import LLMProvider, EmbeddingProvider
+from .factory import LLMFactory, EmbeddingFactory
+
+__all__ = [
+    "LLMProvider",
+    "EmbeddingProvider",
+    "LLMFactory",
+    "EmbeddingFactory",
+]

src/llm/base.py

@@ -0,0 +1,61 @@
+"""LLM Provider 抽象基类"""
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any
+
+
+class LLMProvider(ABC):
+    """LLM 聊天接口抽象基类"""
+
+    @abstractmethod
+    async def chat(
+        self,
+        messages: List[Dict[str, str]],
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+        **kwargs
+    ) -> str:
+        """
+        聊天完成接口
+
+        Args:
+            messages: 消息列表 [{"role": "user", "content": "..."}, ...]
+            temperature: 采样温度
+            max_tokens: 最大生成 token 数
+            **kwargs: 其他参数
+
+        Returns:
+            生成的文本
+        """
+        pass
+
+    @abstractmethod
+    def get_provider_name(self) -> str:
+        """返回 Provider 名称"""
+        pass
+
+
+class EmbeddingProvider(ABC):
+    """Embedding 接口抽象基类"""
+
+    @abstractmethod
+    async def embed(self, text: str) -> List[float]:
+        """
+        文本嵌入接口
+
+        Args:
+            text: 输入文本
+
+        Returns:
+            嵌入向量
+        """
+        pass
+
+    @abstractmethod
+    def get_provider_name(self) -> str:
+        """返回 Provider 名称"""
+        pass
+
+    @abstractmethod
+    def get_embedding_dim(self) -> int:
+        """返回嵌入维度"""
+        pass