Becomer: LLM-agnostic persistent memory API. Store and recall memories across GPT, Claude, Gemini, or any model — zero tokens per recall.

BECOMER — AI 应用的记忆 API

只需 3 行代码，即可为 AI 应用提供持久记忆。

from becomer import Client
mem = Client("bk-your-api-key")
mem.store("User prefers dark mode and speaks French")
memories = mem.recall("user preferences")  # → ['User prefers dark mode...']

→ 获取免费 API 密钥 · 文档 · 基准测试 · 示例

---

为什么选择 BECOMER

大多数记忆解决方案只是附加一个向量存储，就认为大功告成。BECOMER 使用专有检索引擎，并以 LongMemEval 这一长期对话记忆的标准学术基准进行测试。

基准测试	BECOMER	Hindsight（次优）
LongMemEval（500 项测试）	94.4%	91.4%

94.4% 意味着，当用户问“我上周告诉过你我的饮食情况吗？”，系统会找出正确的记忆，而不是一条大致相关的记忆。

---

安装

pip install becomer

零依赖。仅使用纯 Python 标准库。

---

快速开始

from becomer import Client

mem = Client("bk-your-api-key")

# Store anything worth remembering
mem.store("User is building a React app, prefers TypeScript")
mem.store("User's name is Sarah, she's a senior engineer at Stripe")

# Recall before each LLM call
context = mem.recall("what do I know about the user?")
# → ['User is building a React app, prefers TypeScript',
#    "User's name is Sarah, she's a senior engineer at Stripe"]

# Build your prompt with memory injected
system_prompt = "You are a helpful assistant.\n\nWhat you remember:\n" + "\n".join(context)

---

三种集成方式

1. Python SDK（本仓库）

from becomer import Client
mem = Client("bk-your-api-key")
mem.store("...")
mem.recall("...")

2. MCP — 适用于 Claude Desktop、Cursor 及任何 MCP 宿主

{
  "mcpServers": {
    "becomer": {
      "command": "python",
      "args": ["-m", "becomer"],
      "env": { "BECOMER_API_KEY": "bk-your-api-key" }
    }
  }
}

Claude 会自动跨会话存储和回忆记忆。无需更改代码。

3. REST API — 不限编程语言

# Store
curl -X POST https://becomer.net/v1/store \
  -H "Authorization: Bearer bk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"content": "User prefers concise answers"}'

# Recall
curl -X POST https://becomer.net/v1/recall \
  -H "Authorization: Bearer bk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"query": "user preferences", "top_k": 5}'

---

多租户（一个密钥，多个用户）

正在构建一款需要为每位用户提供独立记忆的产品？传入 user_id 即可，无需额外密钥。

from becomer import Client

# One master key for your whole app
mem = Client("bk-your-master-key", user_id="user-alice")
mem.store("Alice prefers Python over JavaScript")

# Different user — completely isolated memory space
mem_bob = Client("bk-your-master-key", user_id="user-bob")
mem_bob.recall("programming preferences")  # → [] (can't see Alice's memories)

# Or override per-call
mem = Client("bk-your-master-key")
mem.store("Bob uses dark mode", user_id="user-bob")
mem.recall("preferences", user_id="user-alice")  # → Alice's memories only

使用按用户隔离的 MCP：

{
  "mcpServers": {
    "becomer": {
      "command": "python",
      "args": ["-m", "becomer"],
      "env": {
        "BECOMER_API_KEY": "bk-your-master-key",
        "BECOMER_USER_ID": "alice-123"
      }
    }
  }
}

REST API：

curl -X POST https://becomer.net/v1/store \
  -H "Authorization: Bearer bk-your-master-key" \
  -H "Content-Type: application/json" \
  -d '{"content": "Alice prefers dark mode", "user_id": "alice-123"}'

user_id 可以是任意字符串：UUID、用户名、电子邮件地址，或应用内部使用的任何标识符。不同 user_id 的记忆完全隔离。费用计入主密钥。

---

LangChain

from langchain.memory import BaseMemory
from becomer import Client
from pydantic import Field

class BecomerMemory(BaseMemory):
    client: object = Field(default=None)
    memory_key: str = "history"

    def __init__(self, api_key: str, **kwargs):
        super().__init__(**kwargs)
        self.client = Client(api_key)

    @property
    def memory_variables(self):
        return [self.memory_key]

    def load_memory_variables(self, inputs):
        query = inputs.get("input", "")
        memories = self.client.recall(query)
        return {self.memory_key: "\n".join(memories)}

    def save_context(self, inputs, outputs):
        self.client.store(f"User: {inputs.get('input','')} | AI: {outputs.get('output','')}")

    def clear(self):
        self.client.forget()

# Usage
from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI

chain = ConversationChain(
    llm=ChatOpenAI(model="gpt-4o"),
    memory=BecomerMemory(api_key="bk-your-api-key")
)
chain.predict(input="My name is Sarah and I work at Stripe")
# Next session — Sarah is still remembered.

---

直接使用 OpenAI / Anthropic

import openai
from becomer import Client

mem = Client("bk-your-api-key")

def chat(user_message: str) -> str:
    context = mem.recall(user_message)
    system = "You are a helpful assistant."
    if context:
        system += "\n\nWhat you remember about the user:\n" + "\n".join(f"- {m}" for m in context)

    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": user_message},
        ]
    )
    reply = response.choices[0].message.content
    mem.store(f"User said: {user_message}")
    return reply

---

API 参考

方法	说明
Client(api_key, user_id=None)	创建客户端。user_id 用于将所有调用限定到某个子用户。
store(content, user_id=None)	存储一条记忆
recall(query, top_k=5, user_id=None)	检索最相关的 top-k 条记忆
forget(user_id=None)	删除此密钥（或子用户）的所有记忆
sync(user_id=None)	将工作记忆整合到长期存储中

完整的 REST API 文档 → becomer.net/docs.html

---

示例

文件	框架
quickstart.py	纯 Python
openai_chat.py	OpenAI SDK
anthropic_chat.py	Anthropic SDK
langchain_memory.py	LangChain
langgraph_memory.py	LangGraph
llamaindex_memory.py	LlamaIndex
crewai_memory.py	CrewAI
autogen_memory.py	AutoGen
mcp.json	MCP（Claude Desktop / Cursor）
mcp_multitenant.json	MCP 多租户

---

定价

方案	每月调用次数	价格
免费版	1,000	永久免费
Pro	50,000	₹1,140/月

免费开始使用 →

---

构建者

Obsidex Pvt Limited · Aravind Balaji，创始人 · [email protected]