isage-middleware 0.1.3.1__py3-none-any.whl → 0.2.0.0__py3-none-any.whl

sage/middleware/examples/microservices_registration_demo.py

@@ -1,140 +0,0 @@
-"""
-SAGE 微服务集成示例
-展示如何正确注册和使用KV、VDB、Graph和Memory服务
-"""
-import time
-from sage.core.api.local_environment import LocalEnvironment
-from sage.middleware.services import (
-    create_kv_service_factory,
-    create_vdb_service_factory,
-    create_graph_service_factory,
-    create_memory_service_factory,
-)
-
-
-def test_microservices_registration():
-    """测试微服务注册"""
-    print("🚀 SAGE Microservices Registration Test")
-    print("=" * 60)
-    
-    # 创建环境
-    env = LocalEnvironment("sage_microservices_test")
-    
-    # 注册所有核心微服务
-    print("\n📋 Registering core microservices")
-    
-    # 注册KV服务
-    kv_factory = create_kv_service_factory("kv_service")
-    env.register_service_factory("kv_service", kv_factory)
-    
-    # 注册VDB服务  
-    vdb_factory = create_vdb_service_factory("vdb_service")
-    env.register_service_factory("vdb_service", vdb_factory)
-    
-    # 注册Memory编排服务
-    memory_factory = create_memory_service_factory("memory_service")
-    env.register_service_factory("memory_service", memory_factory)
-    
-    registered_services = ["kv_service", "vdb_service", "memory_service"]
-    print(f"Registered services: {registered_services}")
-    
-    # 手动注册服务（更灵活的配置）
-    print("\n📋 Manual registration with custom configuration")
-    
-    # 创建环境2用于手动注册
-    env2 = LocalEnvironment("sage_microservices_manual")
-    
-    # KV服务 - 使用Redis后端
-    kv_factory = create_kv_service_factory(
-        service_name="redis_kv_service",
-        backend_type="memory",  # 可以改为"redis"
-        # redis_url="redis://localhost:6379",
-        max_size=50000,
-        ttl_seconds=3600
-    )
-    env2.register_service_factory("redis_kv_service", kv_factory)
-    print("   ✅ Registered redis_kv_service")
-    
-    # VDB服务 - 使用ChromaDB后端
-    vdb_factory = create_vdb_service_factory(
-        service_name="chroma_vdb_service",
-        embedding_dimension=768,
-        index_type="IndexFlatL2",
-    )
-    env2.register_service_factory("chroma_vdb_service", vdb_factory)
-    print("   ✅ Registered chroma_vdb_service")
-    
-    # Graph服务 - 支持知识图谱
-    graph_factory = create_graph_service_factory(
-        service_name="knowledge_graph_service",
-        backend_type="memory",  # 可以改为"neo4j"
-        # neo4j_uri="bolt://localhost:7687",
-        # neo4j_user="neo4j",
-        # neo4j_password="password",
-        max_nodes=500000,
-        max_relationships=2000000
-    )
-    env2.register_service_factory("knowledge_graph_service", graph_factory)
-    print("   ✅ Registered knowledge_graph_service")
-    
-    # Memory服务 - 协调所有服务
-    memory_factory = create_memory_service_factory(
-        service_name="unified_memory_service",
-        kv_service_name="redis_kv_service",
-        vdb_service_name="chroma_vdb_service",
-        graph_service_name="knowledge_graph_service",
-        default_vector_dimension=768,
-        max_search_results=100,
-        enable_caching=True,
-        enable_knowledge_graph=True
-    )
-    env2.register_service_factory("unified_memory_service", memory_factory)
-    print("   ✅ Registered unified_memory_service")
-    
-    print("\n🎯 Service registration completed successfully!")
-    print("\n💡 Key points:")
-    print("   - Services are registered using env.register_service(name, factory)")
-    print("   - Service factories are created using create_*_service_factory() functions")
-    print("   - Services can be configured with different backends (memory, redis, chroma, neo4j)")
-    print("   - Memory service coordinates KV, VDB, and Graph services")
-    print("   - Services inherit from BaseService for SAGE DAG integration")
-    
-    return env, env2
-
-
-def demonstrate_service_configuration():
-    """展示不同的服务配置选项"""
-    print("\n🔧 Service Configuration Options")
-    print("=" * 60)
-    
-    configurations = {
-        "Development": {
-            "kv": {"backend_type": "memory", "max_size": 10000},
-            "vdb": {"backend_type": "memory", "embedding_dimension": 384},
-            "graph": {"backend_type": "memory", "max_nodes": 100000},
-        },
-        "Production": {
-            "kv": {"backend_type": "redis", "redis_url": "redis://prod-redis:6379"},
-            "vdb": {"backend_type": "chroma", "chroma_host": "prod-chroma", "embedding_dimension": 768},
-            "graph": {"backend_type": "neo4j", "neo4j_uri": "bolt://prod-neo4j:7687"},
-        },
-        "Hybrid": {
-            "kv": {"backend_type": "redis", "redis_url": "redis://localhost:6379"},
-            "vdb": {"backend_type": "memory", "embedding_dimension": 512}, 
-            "graph": {"backend_type": "memory", "max_nodes": 200000},
-        }
-    }
-    
-    for config_name, config in configurations.items():
-        print(f"\n📊 {config_name} Configuration:")
-        print(f"   KV:    {config['kv']}")
-        print(f"   VDB:   {config['vdb']}")  
-        print(f"   Graph: {config['graph']}")
-
-
-if __name__ == "__main__":
-    env1, env2 = test_microservices_registration()
-    demonstrate_service_configuration()
-    
-    print("\n🏁 Example completed successfully!")
-    print("You can now use these environments in your SAGE applications.")

sage/middleware/services/__init__.py

@@ -1,56 +0,0 @@
-"""
-SAGE - Streaming-Augmented Generative Execution
-"""
-
-# 动态版本加载
-def _load_version():
-    """从 sage-common 包加载版本信息"""
-    try:
-        # 优先从 sage-common 包加载版本
-        from sage.common._version import __version__
-        return {
-            'version': __version__,
-            'author': 'SAGE Team',
-            'email': 'shuhao_zhang@hust.edu.cn'
-        }
-    except ImportError:
-        # 如果 sage-common 不可用，从项目根目录加载（开发环境）
-        try:
-            from pathlib import Path
-            current_file = Path(__file__).resolve()
-            # 根据当前文件位置计算到项目根目录的层数
-            parts = current_file.parts
-            sage_index = -1
-            for i, part in enumerate(parts):
-                if part == 'SAGE':
-                    sage_index = i
-                    break
-            
-            if sage_index >= 0:
-                root_dir = Path(*parts[:sage_index+1])
-                version_file = root_dir / "_version.py"
-                
-                if version_file.exists():
-                    version_globals = {}
-                    with open(version_file, 'r', encoding='utf-8') as f:
-                        exec(f.read(), version_globals)
-                    return {
-                        'version': version_globals.get('__version__', '0.1.3'),
-                        'author': version_globals.get('__author__', 'SAGE Team'),
-                        'email': version_globals.get('__email__', 'shuhao_zhang@hust.edu.cn')
-                    }
-        except Exception:
-            pass
-    
-    # 最后的默认值
-    return {
-        'version': '0.1.3',
-        'author': 'SAGE Team', 
-        'email': 'shuhao_zhang@hust.edu.cn'
-    }
-
-# 加载信息
-_info = _load_version()
-__version__ = _info['version']
-__author__ = _info['author']
-__email__ = _info['email']

sage/middleware/services/graph/__init__.py

@@ -1,56 +0,0 @@
-"""
-SAGE - Streaming-Augmented Generative Execution
-"""
-
-# 动态版本加载
-def _load_version():
-    """从 sage-common 包加载版本信息"""
-    try:
-        # 优先从 sage-common 包加载版本
-        from sage.common._version import __version__
-        return {
-            'version': __version__,
-            'author': 'SAGE Team',
-            'email': 'shuhao_zhang@hust.edu.cn'
-        }
-    except ImportError:
-        # 如果 sage-common 不可用，从项目根目录加载（开发环境）
-        try:
-            from pathlib import Path
-            current_file = Path(__file__).resolve()
-            # 根据当前文件位置计算到项目根目录的层数
-            parts = current_file.parts
-            sage_index = -1
-            for i, part in enumerate(parts):
-                if part == 'SAGE':
-                    sage_index = i
-                    break
-            
-            if sage_index >= 0:
-                root_dir = Path(*parts[:sage_index+1])
-                version_file = root_dir / "_version.py"
-                
-                if version_file.exists():
-                    version_globals = {}
-                    with open(version_file, 'r', encoding='utf-8') as f:
-                        exec(f.read(), version_globals)
-                    return {
-                        'version': version_globals.get('__version__', '0.1.3'),
-                        'author': version_globals.get('__author__', 'SAGE Team'),
-                        'email': version_globals.get('__email__', 'shuhao_zhang@hust.edu.cn')
-                    }
-        except Exception:
-            pass
-    
-    # 最后的默认值
-    return {
-        'version': '0.1.3',
-        'author': 'SAGE Team', 
-        'email': 'shuhao_zhang@hust.edu.cn'
-    }
-
-# 加载信息
-_info = _load_version()
-__version__ = _info['version']
-__author__ = _info['author']
-__email__ = _info['email']

sage/middleware/services/graph/examples/graph_demo.py

@@ -1,178 +0,0 @@
-"""
-Graph Service 使用示例
-展示如何使用Graph微服务进行知识图谱构建和查询
-"""
-from sage.core.api.local_environment import LocalEnvironment
-from sage.middleware.services.graph import create_graph_service_factory
-
-
-def test_graph_service():
-    """测试Graph服务基本功能"""
-    print("🚀 Graph Service Demo")
-    print("=" * 50)
-    
-    # 创建环境
-    env = LocalEnvironment("graph_service_demo")
-    
-    # 注册Graph服务 - 内存后端
-    graph_factory = create_graph_service_factory(
-        service_name="demo_graph_service",
-        backend_type="memory",
-        max_nodes=10000,
-        max_relationships=50000
-    )
-    # 使用服务工厂注册（与 SAGE Kernel 的 ServiceFactory 对齐）
-    env.register_service_factory("demo_graph_service", graph_factory)
-    
-    print("✅ Graph Service registered with memory backend")
-    print("   - Max nodes: 10,000")
-    print("   - Max relationships: 50,000")
-    
-    # 模拟知识图谱构建
-    print("\n📝 Knowledge Graph Operations Demo:")
-    
-    # 创建实体节点
-    entities = [
-        {"id": "person_1", "labels": ["Person"], "properties": {"name": "Alice", "age": 30}},
-        {"id": "person_2", "labels": ["Person"], "properties": {"name": "Bob", "age": 25}},
-        {"id": "company_1", "labels": ["Company"], "properties": {"name": "TechCorp", "founded": 2010}},
-        {"id": "skill_1", "labels": ["Skill"], "properties": {"name": "Python", "category": "Programming"}},
-        {"id": "skill_2", "labels": ["Skill"], "properties": {"name": "AI", "category": "Technology"}}
-    ]
-    
-    print(f"  add_nodes({len(entities)} entities) -> ✅ Added 5 nodes")
-    for entity in entities:
-        print(f"    - {entity['labels'][0]}: {entity['properties']['name']}")
-    
-    # 创建关系
-    relationships = [
-        {"from_node": "person_1", "to_node": "company_1", "rel_type": "WORKS_AT", "properties": {"since": 2020}},
-        {"from_node": "person_2", "to_node": "company_1", "rel_type": "WORKS_AT", "properties": {"since": 2021}},
-        {"from_node": "person_1", "to_node": "skill_1", "rel_type": "HAS_SKILL", "properties": {"level": "Expert"}},
-        {"from_node": "person_1", "to_node": "skill_2", "rel_type": "HAS_SKILL", "properties": {"level": "Intermediate"}},
-        {"from_node": "person_2", "to_node": "skill_1", "rel_type": "HAS_SKILL", "properties": {"level": "Beginner"}},
-        {"from_node": "person_1", "to_node": "person_2", "rel_type": "COLLEAGUE", "properties": {"since": 2021}}
-    ]
-    
-    print(f"  add_relationships({len(relationships)} relations) -> ✅ Added 6 relationships")
-    for rel in relationships:
-        print(f"    - {rel['from_node']} --[{rel['rel_type']}]--> {rel['to_node']}")
-    
-    # 图查询示例
-    print("\n🔍 Graph Query Examples:")
-    
-    queries = [
-        {
-            "name": "查找Alice的同事",
-            "description": "MATCH (alice:Person {name: 'Alice'})-[:COLLEAGUE]->(colleague) RETURN colleague",
-            "result": "Bob"
-        },
-        {
-            "name": "查找TechCorp的员工",
-            "description": "MATCH (person:Person)-[:WORKS_AT]->(company:Company {name: 'TechCorp'}) RETURN person",
-            "result": "Alice, Bob"
-        },
-        {
-            "name": "查找Python专家",
-            "description": "MATCH (person:Person)-[r:HAS_SKILL]->(skill:Skill {name: 'Python'}) WHERE r.level = 'Expert' RETURN person",
-            "result": "Alice"
-        },
-        {
-            "name": "查找Alice的技能图谱",
-            "description": "MATCH (alice:Person {name: 'Alice'})-[:HAS_SKILL]->(skill:Skill) RETURN skill",
-            "result": "Python (Expert), AI (Intermediate)"
-        }
-    ]
-    
-    for query in queries:
-        print(f"  📊 {query['name']}:")
-        print(f"      Query: {query['description']}")
-        print(f"      Result: {query['result']}")
-    
-    print("\n💡 Graph Service Features:")
-    print("   - 知识图谱构建和管理")
-    print("   - 复杂图查询")
-    print("   - 图算法 (路径查找、社区发现)")
-    print("   - 实体关系推理")
-    print("   - 图可视化支持")
-
-
-def test_graph_algorithms():
-    """演示图算法功能"""
-    print("\n🧮 Graph Algorithms:")
-    
-    algorithms = [
-        {
-            "name": "最短路径",
-            "function": "shortest_path(person_1, person_2)",
-            "description": "查找两个实体间的最短关系路径",
-            "result": "person_1 -> company_1 <- person_2"
-        },
-        {
-            "name": "邻居发现",
-            "function": "get_neighbors(person_1, depth=2)",
-            "description": "查找指定深度内的所有相关实体",
-            "result": "company_1, skill_1, skill_2, person_2"
-        },
-        {
-            "name": "社区检测",
-            "function": "detect_communities()",
-            "description": "发现图中的紧密连接社区",
-            "result": "Community 1: [person_1, person_2, company_1]"
-        },
-        {
-            "name": "中心性分析",
-            "function": "centrality_analysis()",
-            "description": "分析节点在图中的重要性",
-            "result": "company_1: highest centrality (连接最多)"
-        }
-    ]
-    
-    for algo in algorithms:
-        print(f"  🔄 {algo['name']}: {algo['description']}")
-        print(f"      调用: {algo['function']}")
-        print(f"      结果: {algo['result']}")
-
-
-def test_graph_applications():
-    """演示Graph服务的应用场景"""
-    print("\n🎯 Graph Service Applications:")
-    
-    applications = [
-        {
-            "name": "推荐系统",
-            "scenario": "基于用户-物品-属性图进行协同过滤推荐",
-            "entities": ["User", "Item", "Category", "Tag"],
-            "relationships": ["LIKES", "BELONGS_TO", "HAS_TAG", "SIMILAR_TO"]
-        },
-        {
-            "name": "知识问答",
-            "scenario": "构建领域知识图谱，支持复杂问答推理",
-            "entities": ["Concept", "Entity", "Relation", "Attribute"],
-            "relationships": ["IS_A", "PART_OF", "RELATED_TO", "HAS_PROPERTY"]
-        },
-        {
-            "name": "社交网络分析",
-            "scenario": "分析用户关系，发现社区和影响者",
-            "entities": ["User", "Post", "Topic", "Event"],
-            "relationships": ["FOLLOWS", "POSTS", "MENTIONS", "ATTENDS"]
-        },
-        {
-            "name": "欺诈检测",
-            "scenario": "通过异常图模式检测可疑行为",
-            "entities": ["Account", "Transaction", "Device", "Location"],
-            "relationships": ["TRANSFERS", "USES", "LOCATED_AT", "LINKED_TO"]
-        }
-    ]
-    
-    for app in applications:
-        print(f"  📈 {app['name']}: {app['scenario']}")
-        print(f"      实体类型: {', '.join(app['entities'])}")
-        print(f"      关系类型: {', '.join(app['relationships'])}")
-
-
-if __name__ == "__main__":
-    test_graph_service()
-    test_graph_algorithms()
-    test_graph_applications()
-    print("\n🎯 Graph Service demo completed!")

sage/middleware/services/graph/graph_index.py

@@ -1,194 +0,0 @@
-import collections
-import uuid
-import networkx as nx
-import matplotlib.pyplot as plt
-#from sage_memory.search_engine.graph_index.base_graph_index import BaseGraphIndex
-
-class KnowledgeGraphIndex():
-    """
-    Simple knowledge graph storage.
-    基于图的知识存储器。
-    """
-
-    def __init__(self):
-        # 初始化成员变量
-        self.qid2name = collections.defaultdict(str)  # QID ---> entity name
-        self.triples = collections.defaultdict(set)  # (head, rel) ---> set(tail, sentence)
-        self.qid_relations = collections.defaultdict(set)  # QID ---> set(rel)
-
-    def construct_graph(self, batch):
-        """
-        从批次数据中构建知识图谱
-        输入格式: batch = [["head", "relation", "tail"], ...]
-        """
-        for head, relation, tail in batch:
-            # 构造三元组的句子
-            sentence = f"{head} --[{relation}]--> {tail}"
-            # 插入三元组
-            self.insert_edge(head, relation, tail, sentence)
-
-    def insert_edge(self, head, relation, tail, sentence):
-        """
-        插入一条新的边 (head, relation, tail)
-        """
-        head_id=uuid.uuid5(uuid.NAMESPACE_DNS, head)
-        tail_id=uuid.uuid5(uuid.NAMESPACE_DNS, tail)
-        
-        # 添加 head 和 tail 的名称映射
-        if head_id not in self.qid2name:
-            self.qid2name[head_id] = head
-        if tail_id not in self.qid2name:
-            self.qid2name[tail_id] = tail
-
-        # 检查 triples 中是否已存在该三元组
-        if (tail_id, sentence) not in self.triples[(head_id, relation)]:
-            self.triples[(head_id, relation)].add((tail_id, sentence))
-
-        # 检查 qid_relations 中是否已存在该关系
-        if relation not in self.qid_relations[head_id]:
-            self.qid_relations[head_id].add(relation)
-
-    
-    def delete_edge(self, head, relation, tail):
-        """
-        删除知识图谱中的一条边 (head, relation, tail)
-        """
-        # 生成唯一的 ID
-        head_id = uuid.uuid5(uuid.NAMESPACE_DNS, head)
-        tail_id = uuid.uuid5(uuid.NAMESPACE_DNS, tail)
-        # 从 triples 中删除对应的三元组
-        if (head_id, relation) in self.triples:
-            self.triples[(head_id, relation)] = {
-                t for t in self.triples[(head_id, relation)] if t[0] != tail_id
-            }
-            # 如果关系为空，则从 qid_relations 中移除
-            if not self.triples[(head_id, relation)]:
-                del self.triples[(head_id, relation)]
-                self.qid_relations[head_id].remove(relation)
-    
-    def modify_edge(self, head, relation, tail, new_tail):
-        """
-        修改知识图谱中的一条边 (head, relation, tail) 为 (head, relation, new_tail)
-        """
-        # 生成唯一的 ID
-        head_id = uuid.uuid5(uuid.NAMESPACE_DNS, head)
-        tail_id = uuid.uuid5(uuid.NAMESPACE_DNS, tail)
-        new_tail_id = uuid.uuid5(uuid.NAMESPACE_DNS, new_tail)
-
-        # 检查是否存在该关系
-        if (head_id, relation) in self.triples:
-            # 获取当前关系中的所有尾节点
-            current_tails = self.triples[(head_id, relation)]
-            
-
-            # 检查是否存在指定的尾节点
-            tail_exists = False
-            for tail_id_in_graph, sentence in current_tails:
-                if tail_id_in_graph == tail_id:
-                    tail_exists = True
-                    # 修改尾节点为 new_tail
-                    current_tails.remove((tail_id_in_graph, sentence))
-                    new_sentence = f"{head} --[{relation}]--> {new_tail}"
-                    current_tails.add((new_tail_id, new_sentence))
-                    if new_tail_id not in self.qid2name:
-                        self.qid2name[new_tail_id] = new_tail
-                    break
-
-            if not tail_exists:
-                print(f"Edge ({head}, {relation}, {tail}) does not exist.")
-                return
-        else:
-            print(f"Relation ({head}, {relation}) does not exist in the graph.")
-
-
-    def clear_relation(self, head, relation):
-        head_id = uuid.uuid5(uuid.NAMESPACE_DNS, head)
-        if (head_id, relation) in self.triples:
-            del self.triples[(head_id, relation)]
-            self.qid_relations[head_id].remove(relation)
-
-    def get_neighbors(self, entity):
-        neighbors = set()
-        head_id = uuid.uuid5(uuid.NAMESPACE_DNS, entity)
-        for relation in self.qid_relations[head_id]:
-            for tail, _ in self.triples[(head_id, relation)]:
-                neighbors.add((relation, tail))
-        for relation, tail in neighbors:
-            print(f"Relation: {relation}, Tail: {self.qid2name[tail]}")
-        return neighbors
-    
-
-    def print_graph(self):
-        """
-        打印知识图谱的内容
-        """
-        print("Knowledge Graph:")
-        for (head_id, relation), tails in self.triples.items():
-            for tail_id, sentence in tails:
-                print(f"{self.qid2name[head_id]} --[{relation}]--> {self.qid2name[tail_id]}")
-
-
-    def visualize_knowledge_graph(self):
-        """
-        可视化知识图谱
-        """
-        # 创建一个有向图
-        G = nx.DiGraph()
-
-        # 添加节点和边
-        for (head_id, relation), tails in self.triples.items():  # 使用 self 访问成员变量
-            head_name = self.qid2name[head_id]
-            for tail_id, sentence in tails:
-                tail_name = self.qid2name[tail_id]
-                G.add_edge(head_name, tail_name, label=relation)
-
-        # 绘制图形
-        pos = nx.spring_layout(G)  # 使用 spring 布局
-        plt.figure(figsize=(12, 8))
-
-        # 绘制节点和边
-        nx.draw(G, pos, with_labels=True, node_size=3000, node_color="lightblue", font_size=10, font_weight="bold")
-        
-        # 绘制边上的标签
-        edge_labels = nx.get_edge_attributes(G, 'label')
-        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8)
-
-        # 显示图形
-        plt.title("Knowledge Graph Visualization", fontsize=16)
-        plt.savefig("knowledge_graph.png")  # 保存图形到文件
-
-if __name__ == "__main__":
-    # 创建 KnowledgeGraphStorage 实例
-    kg_storage = KnowledgeGraphIndex()
-
-    # 定义测试数据
-    batch = [
-        ["Trump", "president_of", "USA"],
-        ["Trump", "fans_of", "CR7"],
-        ["Trump", "fans_of", "Mask"],
-        ["CR7", "rival_of", "Messi"],
-        ["CR7", "play_for", "Manchester United"],
-        ["CR7", "born_in", "Portugal"],
-        ["Manchester United", "located_in", "England"],
-    ]
-
-    # 构建知识图谱
-    kg_storage.construct_graph(batch)
-
-    # 打印知识图谱内容
-    print("测试输出:")
-    kg_storage.print_graph()
-    print()
-
-    print("CR7效力的球队发生了变化，需要修改知识图谱中的边:")
-    kg_storage.modify_edge("CR7", "play_for", "Manchester United", "Al-Nassr FC")
-    kg_storage.print_graph()
-    print()
-
-    print("Trump和Mask闹掰了，需要删除知识图谱中的边:")
-    kg_storage.delete_edge("Trump", "fans_of", "Mask")
-    kg_storage.print_graph()
-
-    kg_storage.get_neighbors("CR7")
-    # 可视化知识图谱
-    kg_storage.visualize_knowledge_graph()