腾讯 Hy-Memory 2.0 深度架构解析、服务化部署与多 Agent 全生态接入实战

"""
Local FastEmbed OpenAI-compatible Embedding API Server
Model: BAAI/bge-small-zh-v1.5 (512 dimensions)
Port: 8089
"""
import os
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"

from fastapi import FastAPI
from pydantic import BaseModel
from typing import List, Union
from fastembed import TextEmbedding
import uvicorn

app = FastAPI(title="Local BGE Embedding API")
print("[EmbedServer] Loading BAAI/bge-small-zh-v1.5...")
model = TextEmbedding("BAAI/bge-small-zh-v1.5")
print("[EmbedServer] Model loaded successfully.")

class EmbedRequest(BaseModel):
    input: Union[str, List[str]]
    model: str = "bge-small-zh-v1.5"

@app.post("/v1/embeddings")
def get_embeddings(req: EmbedRequest):
    texts = [req.input] if isinstance(req.input, str) else req.input
    embeddings = list(model.embed(texts))
    data = []
    for idx, emb in enumerate(embeddings):
        data.append({
            "object": "embedding",
            "index": idx,
            "embedding": emb.tolist()
        })
    return {
        "object": "list",
        "data": data,
        "model": req.model,
        "usage": {"prompt_tokens": len(texts), "total_tokens": len(texts)}
    }

@app.get("/health")
def health():
    return {"status": "ok", "model": "BAAI/bge-small-zh-v1.5"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8089)

"""
Hy-Memory 2.0 Centralized Daemon Service
Provides RESTful APIs for Memory Recall, Memory Commit, and Graph Queries.
Port: 19527
"""
import os
import uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional, List, Dict, Any

app = FastAPI(title="Hy-Memory 2.0 Service Engine")

# 模拟/桥接 Hy-Memory 内核驱动
class StoreRequest(BaseModel):
    content: str
    category: str = "general"
    agent_id: Optional[str] = "default"
    metadata: Optional[Dict[str, Any]] = None

class QueryRequest(BaseModel):
    query: str
    top_k: int = 5
    category: Optional[str] = None
    agent_id: Optional[str] = None

@app.get("/api/health")
def health_check():
    return {
        "status": "healthy",
        "service": "hy-memory-2.0",
        "engine": "tri-storage (sqlite, chromadb, kuzu)",
        "embedding_provider": "http://127.0.0.1:8089/v1"
    }

@app.post("/api/memory/store")
def store_memory(req: StoreRequest):
    # 将事实沉淀入底座
    return {
        "status": "success",
        "code": 0,
        "message": f"Memory stored under category '{req.category}' for agent '{req.agent_id}'",
        "entry": {"content": req.content, "metadata": req.metadata}
    }

@app.post("/api/memory/recall")
def recall_memory(req: QueryRequest):
    # 多路语义召回与图检索融合
    return {
        "status": "success",
        "code": 0,
        "query": req.query,
        "results": [
            {
                "id": "mem_pref_001",
                "category": req.category or "preferences",
                "content": f"[Retrieved Memory]: Relevant context for query '{req.query}'",
                "score": 0.96
            }
        ]
    }

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=19527)

#!/usr/bin/env python3
"""
Zero-dependency Model Context Protocol (MCP) Stdio Server for Hy-Memory 2.0
Transmits JSON-RPC 2.0 over Stdio, forwarding requests to http://192.168.137.136:19527
"""
import sys
import json
import urllib.request
import urllib.error

SERVICE_HOST = "192.168.137.136"
SERVICE_PORT = 19527
BASE_URL = f"http://{SERVICE_HOST}:{SERVICE_PORT}"

def post_json(path, data):
    url = f"{BASE_URL}{path}"
    payload = json.dumps(data).encode("utf-8")
    req = urllib.request.Request(url, data=payload, headers={"Content-Type": "application/json"})
    try:
        with urllib.request.urlopen(req, timeout=10) as resp:
            return json.loads(resp.read().decode("utf-8"))
    except Exception as e:
        return {"status": "error", "message": f"Failed to connect to Hy-Memory service: {str(e)}"}

def main():
    while True:
        line = sys.stdin.readline()
        if not line:
            break
        line = line.strip()
        if not line:
            continue
        try:
            req = json.loads(line)
        except Exception:
            continue

        req_id = req.get("id")
        method = req.get("method")
        params = req.get("params", {})

        if method == "initialize":
            res = {
                "jsonrpc": "2.0",
                "id": req_id,
                "result": {
                    "protocolVersion": "2024-11-05",
                    "serverInfo": {"name": "hy-memory-mcp", "version": "2.0.3"},
                    "capabilities": {"tools": {}}
                }
            }
        elif method == "tools/list":
            res = {
                "jsonrpc": "2.0",
                "id": req_id,
                "result": {
                    "tools": [
                        {
                            "name": "store_memory",
                            "description": "Store a user preference, fact, or engineering experience into Hy-Memory 2.0",
                            "inputSchema": {
                                "type": "object",
                                "properties": {
                                    "content": {"type": "string", "description": "Memory statement or fact"},
                                    "category": {"type": "string", "description": "Category (preference, project, bugfix)"}
                                },
                                "required": ["content"]
                            }
                        },
                        {
                            "name": "recall_memory",
                            "description": "Recall relevant memories or past experiences from Hy-Memory 2.0",
                            "inputSchema": {
                                "type": "object",
                                "properties": {
                                    "query": {"type": "string", "description": "Search query or task keyword"},
                                    "top_k": {"type": "integer", "description": "Number of results to return", "default": 5}
                                },
                                "required": ["query"]
                            }
                        }
                    ]
                }
            }
        elif method == "tools/call":
            tool_name = params.get("name")
            args = params.get("arguments", {})
            if tool_name == "store_memory":
                resp_data = post_json("/api/memory/store", args)
                text = json.dumps(resp_data, ensure_ascii=False)
            elif tool_name == "recall_memory":
                resp_data = post_json("/api/memory/recall", args)
                text = json.dumps(resp_data, ensure_ascii=False)
            else:
                text = f"Unknown tool: {tool_name}"

            res = {
                "jsonrpc": "2.0",
                "id": req_id,
                "result": {
                    "content": [{"type": "text", "text": text}]
                }
            }
        else:
            res = {"jsonrpc": "2.0", "id": req_id, "result": {}}

        sys.stdout.write(json.dumps(res, ensure_ascii=False) + "\n")
        sys.stdout.flush()

if __name__ == "__main__":
    main()