你的 AI 助手还在“金鱼记忆”?这个开源项目让 ChatGPT 学会了主动找你

2026年10月20日 | 来源:GitHub Trending
AI助手 开源项目 Agent
你有没有想过,为什么 AI 助手永远是“你问我答”的被动模式?它不会在你该开会前提醒你,不记得你上周说过的话,更不会主动关心你的项目进度。GitHub 上一个叫 eve 的开源项目,正在尝试打破这个僵局——一个真正“always-on”、有长期记忆、还会主动发消息找你的个人 AI 助手。

一、从“问答机器”到“数字管家”:AI 助手的范式缺失

过去两年,我们见证了 AI 对话能力的爆炸式提升,但一个根本性问题始终没有被很好解决:AI 助手没有“存在感”。

你打开 ChatGPT,它才“醒来”;你关掉窗口,它就“消失”。它不记得你昨天告诉它的项目 deadline,更不可能在你睡过头时主动给你发一条 Telegram 消息。

这其实是三个能力维度的缺失:

1. 常驻性(Always-on):助手需要持续运行,而不是按需唤醒

2. 长期记忆(Long-term Memory):跨会话记住用户偏好、历史对话和重要事项

3. 主动性(Proactive):基于时间、事件或规则主动触达用户,而非被动响应

GitHub Trending 上的开源项目 eve(EnergyBoyTW/eve),正是围绕这三个维度构建的。它目前还处于早期阶段(12 stars),但架构设计相当完整,对个人开发者来说极具参考价值。

二、eve 的核心架构:四大能力模块

根据项目描述,eve 是一个“Always-on 个人 AI 助手”,核心能力包括:

我们用一张架构图来看整体设计:

Web 聊天 Telegram Bot 应用集成 Eve 核心引擎 Always-on 调度 / 意图路由 长期记忆库 主动提醒调度器 一键部署 Builder 用户多端接入 → 核心引擎统一调度 → 记忆与主动性支撑

1. 长期记忆:不只是“聊天记录”

大多数项目的“记忆”就是把对话历史一股脑塞进 context。而一个合格的长期记忆系统,至少需要:

一个典型的记忆写入与召回流程可以这样做:

from dataclasses import dataclass
import numpy as np

@dataclass
class Memory:
    content: str
    embedding: np.ndarray
    timestamp: str
    importance: float  # 重要度评分,用于遗忘/筛选

class LongTermMemory:
    def __init__(self, embed_fn, threshold=0.75):
        self.memories: list[Memory] = []
        self.embed = embed_fn
        self.threshold = threshold

    def remember(self, text: str, ts: str):
        """对话结束后提取值得记住的信息"""
        emb = self.embed(text)
        # 去重:与已有记忆相似度过高则跳过
        for m in self.memories:
            if float(np.dot(m.embedding, emb)) > self.threshold:
                return
        self.memories.append(Memory(text, emb, ts, importance=0.5))

    def recall(self, query: str, top_k: int = 5) -> list[str]:
        """新对话到来时,召回相关记忆注入上下文"""
        q = self.embed(query)
        scored = sorted(
            self.memories,
            key=lambda m: np.dot(m.embedding, q) + m.importance * 0.3,
            reverse=True,
        )
        return [m.content for m in scored[:top_k]]

生产环境中,self.memories 应替换为向量数据库(如 Chroma、Qdrant、pgvector),并加上记忆衰减和合并机制——否则记忆库会膨胀成噪音堆。

2. 主动提醒:让 AI 第一次“主动开口”

这是 eve 最有意思的能力。技术上,主动触达的核心是一个后台调度器 + 消息通道的组合:

import asyncio
from datetime import datetime

class ProactiveScheduler:
    """后台常驻任务:到点主动通过 Telegram 推送消息"""
    def __init__(self, tg_bot, llm):
        self.tg_bot = tg_bot
        self.llm = llm
        self.reminders = []  # (触发时间, 用户指令上下文)

    def add(self, when: datetime, user_intent: str):
        self.reminders.append((when, user_intent))

    async def run(self):
        while True:
            now = datetime.now()
            due = [r for r in self.reminders if r[0] <= now]
            for when, intent in due:
                # 不是机械转发,而是让 LLM 结合记忆组织提醒语
                msg = await self.llm.generate(
                    f"现在是 {when},用户之前要求:{intent}。"
                    f"请生成一条自然、简洁的主动提醒。"
                )
                await self.tg_bot.send(msg)
                self.reminders.remove((when, intent))
            await asyncio.sleep(30)

关键设计点在于:提醒消息不是模板化的 “您有一个提醒”,而是让 LLM 结合记忆和上下文生成自然语言。这才是“助手感”和“闹钟感”的区别。

3. Telegram + Web 双通道

Telegram 是个人 AI 助手的天然载体——免费、全球可达、Bot API 成熟、支持推送。eve 的做法是把 Telegram 作为移动端的“主动触达”通道,Web 端作为主要交互界面,两者共享同一个记忆库和会话状态。

4. 一键部署 Builder:被低估的设计

eve 内置了一个 builder,可以把配置好的助手实例一键部署复刻。这个功能的意义常被忽视:

三、为什么这类项目值得关注?

自托管 = 数据主权

用商业 AI 助手,你的所有对话、偏好、日程都在别人服务器上。而 eve 这类开源自托管方案,记忆数据完全掌握在自己手里。当你的 AI 助手越来“懂你”,数据的敏感度就越高——记忆越有价值,自托管就越必要。

“主动性”是 AI Agent 落地的关键拼图

当前的 Agent 热潮集中在“工具调用”和“任务执行”,但真正的个人助理场景中,时间维度上的主动性可能更重要。你的真人助理最有价值的时刻,往往不是你提问时,而是TA主动提醒你“半小时后有个会”的时候。eve 的 proactive reminders 正是在补这块拼图。

早期项目的参与窗口

目前 eve 只有 12 stars,处于非常早期。对开发者来说,这类项目是参与开源、学习 Agent 架构设计的好机会;从 README 结构和功能完整度看,作者(EnergyBoyTW)对产品形态有清晰思考,值得 star 追踪。

四、冷静看待:挑战依然存在

当然,也要泼点冷水:

1. 成本问题:always-on + 长期记忆意味着持续的 token 消耗,每次对话都要检索记忆、注入上下文,个人长期运行的账单不可忽视

2. 记忆治理:长期记忆系统最大的难题不是“存”,而是“忘”——过时信息如何更新、矛盾记忆如何消解、错误信息如何纠正,这些都需要精细设计

3. 可靠性:主动提醒意味着 AI 拥有“打扰你”的权力,误触发率必须压得足够低,否则用户会瞬间关掉通知权限

写在最后

从 ChatGPT 到 eve,AI 助手的演进方向越来越清晰:从“更强的模型”走向“更完整的产品形态”——常驻、记忆、主动、集成,缺一不可。eve 这样的项目虽然年轻,但它指向的未来是:一个真正住在你数字生活里、认识你、记得你、会主动找你的 AI。

如果你也想拥有一个完全属于自己的 AI 助手,不妨去 GitHub 上给它一个 star,然后亲手部署一个试试。


信息源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve) 查看原文 ↗
推广
🚀 想亲手把文中的 AI 项目跑起来?
阿里云轻量应用服务器,开箱即用,新用户专享优惠——半小时从零部署一台自己的 AI 工作机。
去了解 →

📋 多平台草稿预览 (12平台差异化改编)

你的 AI 助手还在“金鱼记忆”?这个开源项目让 ChatGPT 学会了主动找你

你有没有想过,为什么 AI 助手永远是“你问我答”的被动模式?它不会在你该开会前提醒你,不记得你上周说过的话,更不会主动关心你的项目进度。GitHub 上一个叫 eve 的开源项目,正在尝试打破这个僵局——一个真正“always-on”、有长期记忆、还会主动发消息找你的个人 AI 助手。

你有没有想过,为什么 AI 助手永远是“你问我答”的被动模式?它不会在你该开会前提醒你,不记得你上周说过的话,更不会主动关心你的项目进度。GitHub 上一个叫 eve 的开源项目,正在尝试打破这个僵局——一个真正“always-on”、有长期记忆、还会主动发消息找你的个人 AI 助手。

一、从“问答机器”到“数字管家”:AI 助手的范式缺失

过去两年,我们见证了 AI 对话能力的爆炸式提升,但一个根本性问题始终没有被很好解决:AI 助手没有“存在感”。

你打开 ChatGPT,它才“醒来”;你关掉窗口,它就“消失”。它不记得你昨天告诉它的项目 deadline,更不可能在你睡过头时主动给你发一条 Telegram 消息。

这其实是三个能力维度的缺失:

1. 常驻性(Always-on):助手需要持续运行,而不是按需唤醒

2. 长期记忆(Long-term Memory):跨会话记住用户偏好、历史对话和重要事项

3. 主动性(Proactive):基于时间、事件或规则主动触达用户,而非被动响应

GitHub Trending 上的开源项目 eve(EnergyBoyTW/eve),正是围绕这三个维度构建的。它目前还处于早期阶段(12 stars),但架构设计相当完整,对个人开发者来说极具参考价值。

二、eve 的核心架构:四大能力模块

根据项目描述,eve 是一个“Always-on 个人 AI 助手”,核心能力包括:

    • Web 聊天界面:浏览器内的对话入口
    • Telegram 集成:通过 Telegram Bot 随时随地与助手交互
    • 主动提醒(Proactive Reminders):助手可以自己发起消息
    • 长期记忆:跨会话持久化用户信息
    • 应用集成(App Integrations):连接外部服务
    • 一键部署 Builder:生成配置好的复刻实例

我们用一张架构图来看整体设计:

Web 聊天 Telegram Bot 应用集成 Eve 核心引擎 Always-on 调度 / 意图路由 长期记忆库 主动提醒调度器 一键部署 Builder 用户多端接入 → 核心引擎统一调度 → 记忆与主动性支撑

1. 长期记忆:不只是“聊天记录”

大多数项目的“记忆”就是把对话历史一股脑塞进 context。而一个合格的长期记忆系统,至少需要:

    • 记忆提取:从对话中识别值得持久化的信息(偏好、事实、待办)
    • 向量化存储:用 embedding 存入向量数据库
    • 相关性检索:新对话到来时,召回相关记忆注入 prompt

一个典型的记忆写入与召回流程可以这样做:

from dataclasses import dataclass

import numpy as np

@dataclass

class Memory:

content: str

embedding: np.ndarray

timestamp: str

importance: float # 重要度评分,用于遗忘/筛选

class LongTermMemory:

def __init__(self, embed_fn, threshold=0.75):

self.memories: list[Memory] = []

self.embed = embed_fn

self.threshold = threshold

def remember(self, text: str, ts: str):

"""对话结束后提取值得记住的信息"""

emb = self.embed(text)

# 去重:与已有记忆相似度过高则跳过

for m in self.memories:

if float(np.dot(m.embedding, emb)) > self.threshold:

return

self.memories.append(Memory(text, emb, ts, importance=0.5))

def recall(self, query: str, top_k: int = 5) -> list[str]:

"""新对话到来时,召回相关记忆注入上下文"""

q = self.embed(query)

scored = sorted(

self.memories,

key=lambda m: np.dot(m.embedding, q) + m.importance * 0.3,

reverse=True,

)

return [m.content for m in scored[:top_k]]

生产环境中,self.memories 应替换为向量数据库(如 Chroma、Qdrant、pgvector),并加上记忆衰减和合并机制——否则记忆库会膨胀成噪音堆。

2. 主动提醒:让 AI 第一次“主动开口”

这是 eve 最有意思的能力。技术上,主动触达的核心是一个后台调度器 + 消息通道的组合:

import asyncio

from datetime import datetime

class ProactiveScheduler:

"""后台常驻任务:到点主动通过 Telegram 推送消息"""

def __init__(self, tg_bot, llm):

self.tg_bot = tg_bot

self.llm = llm

self.reminders = [] # (触发时间, 用户指令上下文)

def add(self, when: datetime, user_intent: str):

self.reminders.append((when, user_intent))

async def run(self):

while True:

now = datetime.now()

due = [r for r in self.reminders if r[0] <= now]

for when, intent in due:

# 不是机械转发,而是让 LLM 结合记忆组织提醒语

msg = await self.llm.generate(

f"现在是 {when},用户之前要求:{intent}。"

f"请生成一条自然、简洁的主动提醒。"

)

await self.tg_bot.send(msg)

self.reminders.remove((when, intent))

await asyncio.sleep(30)

关键设计点在于:提醒消息不是模板化的 “您有一个提醒”,而是让 LLM 结合记忆和上下文生成自然语言。这才是“助手感”和“闹钟感”的区别。

3. Telegram + Web 双通道

Telegram 是个人 AI 助手的天然载体——免费、全球可达、Bot API 成熟、支持推送。eve 的做法是把 Telegram 作为移动端的“主动触达”通道,Web 端作为主要交互界面,两者共享同一个记忆库和会话状态。

4. 一键部署 Builder:被低估的设计

eve 内置了一个 builder,可以把配置好的助手实例一键部署复刻。这个功能的意义常被忽视:

    • 对个人用户:不用从零写配置,填好 API key 和偏好即可获得自己的助手
    • 对开发者:可以把“定制助手”作为产品分发给他人——给团队每个人配一个懂业务流程的助手
    • 对生态:这实际上是“助手即模板”(Assistant-as-Template)的思路,类似于 GPTs 但完全开源可控

三、为什么这类项目值得关注?

自托管 = 数据主权

用商业 AI 助手,你的所有对话、偏好、日程都在别人服务器上。而 eve 这类开源自托管方案,记忆数据完全掌握在自己手里。当你的 AI 助手越来“懂你”,数据的敏感度就越高——记忆越有价值,自托管就越必要。

“主动性”是 AI Agent 落地的关键拼图

当前的 Agent 热潮集中在“工具调用”和“任务执行”,但真正的个人助理场景中,时间维度上的主动性可能更重要。你的真人助理最有价值的时刻,往往不是你提问时,而是TA主动提醒你“半小时后有个会”的时候。eve 的 proactive reminders 正是在补这块拼图。

早期项目的参与窗口

目前 eve 只有 12 stars,处于非常早期。对开发者来说,这类项目是参与开源、学习 Agent 架构设计的好机会;从 README 结构和功能完整度看,作者(EnergyBoyTW)对产品形态有清晰思考,值得 star 追踪。

四、冷静看待:挑战依然存在

当然,也要泼点冷水:

1. 成本问题:always-on + 长期记忆意味着持续的 token 消耗,每次对话都要检索记忆、注入上下文,个人长期运行的账单不可忽视

2. 记忆治理:长期记忆系统最大的难题不是“存”,而是“忘”——过时信息如何更新、矛盾记忆如何消解、错误信息如何纠正,这些都需要精细设计

3. 可靠性:主动提醒意味着 AI 拥有“打扰你”的权力,误触发率必须压得足够低,否则用户会瞬间关掉通知权限

写在最后

从 ChatGPT 到 eve,AI 助手的演进方向越来越清晰:从“更强的模型”走向“更完整的产品形态”——常驻、记忆、主动、集成,缺一不可。eve 这样的项目虽然年轻,但它指向的未来是:一个真正住在你数字生活里、认识你、记得你、会主动找你的 AI。

如果你也想拥有一个完全属于自己的 AI 助手,不妨去 GitHub 上给它一个 star,然后亲手部署一个试试。



信息源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve) 标签:AI助手, 开源项目, Agent

来源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve)

原文:https://www.rainbowonionai.cn/energyboytweve.html

🎬 本机管线自动渲染成片(未发布,人工审片前仅供参考)

【视频脚本总览】总时长 60 秒 | 竖屏 9:16 | 中快语速,每句不超过 15 字,钩子和 CTA 处放慢收力

【分镜 1|0-3秒|黄金钩子】

画面:手机弹出一条 Telegram 消息特写,配红色惊叹号贴纸

口播:GitHub 上一个只有 12 个星的项目,想让 AI 主动开口找你。

字幕:12 星项目,AI 主动找你?!

【分镜 2|3-15秒|事件铺开】

画面:切 GitHub 页面录屏,光标圈出项目名 eve

口播:项目叫 eve。它是常驻运行的,不关机。你有长期记忆,跨会话记住你说过的话。最狠的是主动提醒,它不等你问,自己给你发消息。Telegram 和网页,双通道都能用。

字幕:eve|常驻+记忆+主动提醒

【分镜 3|15-32秒|核心冲突】

画面:左右分屏,左边 ChatGPT 关窗就黑屏,右边 eve 消息弹出

口播:你现在的 AI 助手什么样?打开才醒,关掉就消失。上周说的话,它一个字不记得。为什么?因为它是你问它答,没有存在感。真人助理最值钱的时刻,不是你提问的时候,是他提醒你,半小时后有个会。这块,全行业都缺。

字幕:AI 没有存在感,问题出在这

【分镜 4|32-45秒|数据实证】

画面:架构图逐块弹出,高亮“长期记忆库”和“提醒调度器”

口播:eve 的提醒不是闹钟那种“您有一个提醒”。它是让大模型结合记忆,生成一句自然的话。记忆用向量数据库存,Chroma、pgvector 都行,新对话来了自动召回。还记得那个 12 星吗?早期阶段,架构已经很完整。

字幕:LLM 生成提醒,不是模板

【分镜 5|45-55秒|反直觉升华】

画面:服务器机箱实拍 + 一把钥匙插进锁孔的特写

口播:更反常识的一点:助手越懂你,数据越敏感。商业助手的记忆在别人服务器上,eve 是自托管,记忆全在自己手里。还有个一键部署,可以把你的定制助手,复制给团队每个人。

字幕:越懂你,越要自己管数据

【分镜 6|55-60秒|互动CTA】

画面:博主出镜指镜头,评论区截图动画

口播:这个 12 星项目,你会给 AI 主动发消息的权利吗?评论区聊聊。关注我,每天带你看被低估的开源项目。

字幕:你会让 AI 主动找你吗?

【BGM与节奏】电子感、低频推进型 BGM,0-3 秒静音后重鼓点进钩子;32 秒架构图弹出逐个卡点配“叮”音效;55 秒 BGM 抽空半秒再起,收尾干净

【素材清单】

分镜 1:Telegram 消息推送界面截图 + 惊叹号贴纸动效

分镜 2:GitHub 项目页录屏(EnergyBoyTW/eve)

分镜 3:ChatGPT 关窗黑屏实拍 + eve 消息弹出录屏,左右分屏

分镜 4:文章架构图,逐块弹出动效

分镜 5:服务器机箱实拍 + 钥匙开锁特写实拍

分镜 6:博主真人出镜 + 评论区动画贴纸


来源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve)

原文:https://www.rainbowonionai.cn/energyboytweve.html

你的 AI 助手还在“金鱼记忆”?这个开源项目让 ChatGPT 学会了主动找你 🔥

你有没有想过,为什么 AI 助手永远是“你问我答”的被动模式?它不会在你该开会前提醒你,不记得你上周说过的话,更不会主动关心你的项目进度。GitHub 上一个叫 eve 的开源项目,正在尝试打破这个僵局——一个真正“always-on”、有长期记忆、还会主动发消息找你的个人 AI 助手。


你有没有想过,为什么 AI 助手永远是“你问我答”的被动模式?它不会在你该开会前提醒你,不记得你上周说过的话,更不会主动关心你的项目进度。GitHub 上一个叫 eve 的开源项目,正在尝试打破这个僵局——一个真正“always-on”、有长期记忆、还会主动发消息找你的个人 AI 助手。

过去两年,我们见证了 AI 对话能力的爆炸式提升,但一个根本性问题始终没有被很好解决:AI 助手没有“存在感”。

你打开 ChatGPT,它才“醒来”;你关掉窗口,它就“消失”。它不记得你昨天告诉它的项目 deadline,更不可能在你睡过头时主动给你发一条 Telegram 消息。


📌 来源:GitHub Trending

#AI助手 #开源项目 #Agent

#科技资讯 #彩虹洋葱AI


来源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve)

原文:https://www.rainbowonionai.cn/energyboytweve.html

先说结论:eve 这个项目最有价值的不是代码,而是它指出了一个几乎所有主流 AI 助手都在回避的范式缺口——AI 助手没有“时间维度”。

先交代背景,不吹。GitHub Trending 上的 eve(EnergyBoyTW/eve)目前只有 12 stars,处于早期阶段。我为什么要认真聊一个 12 stars 的项目?因为它用一套相当完整的架构,验证了一条路可行:常驻(always-on)、长期记忆、主动触达,这三件事恰恰是 ChatGPT 这类“你问我答”产品至今没做的。

配图

你关掉浏览器窗口,你的 AI 助手就“死”了。它不记得你昨天说的项目 deadline,不可能在你该开会前主动发一条 Telegram 消息。这不是体验问题,是架构问题——三个能力维度同时缺失:

1. 常驻性:助手持续运行,而不是按需唤醒;

2. 长期记忆:跨会话记住偏好、历史和重要事项;

3. 主动性:基于时间或事件主动触达用户,而非被动响应。

eve 的六项功能——Web 聊天界面、Telegram 集成、主动提醒、长期记忆、应用集成、一键部署 Builder——全部围绕这三个维度展开。

【配图建议:深色背景中一盏台灯持续亮着,旁边是亮屏的手机,象征 always-on 的常驻状态】

第一层:长期记忆不等于聊天记录堆砌。

很多项目的“记忆”实现,本质上就是对话历史一股脑塞进 context。而一个合格的长期记忆系统至少需要三步:从对话中提取值得持久化的信息(偏好、事实、待办),用 embedding 向量化存入数据库,新对话到来时做相关性检索并注入 prompt。eve 的实现思路还包含了去重设计——示例代码中用 0.75 的相似度阈值判断新记忆与已有记忆是否重复,重复则跳过写入。这是很多初学者实现记忆系统时容易忽略的细节:没有去重和筛选,记忆库迟早膨胀成噪音堆。生产环境中应该用 Chroma、Qdrant、pgvector 这类向量数据库替代内存列表,并加上记忆衰减和合并机制。

第二层:主动提醒,让 AI 第一次“主动开口”。

这是我觉得 eve 最有意思的部分。技术上,核心是“后台调度器 + 消息通道”的组合:一个常驻的 asyncio 循环,每 30 秒轮询一次到期任务,到点后通过 Telegram Bot 推送。但关键设计点不在这,而在于提醒消息不是模板化的“您有一个提醒”,而是让 LLM 结合记忆和上下文生成自然语言。这才是“助手感”和“闹钟感”的区别——前者像有人惦记你,后者只是机器响铃。

【配图建议:手机屏幕上弹出一条 Telegram 消息通知,屏幕微光,画面简洁】

第三层:Telegram + Web 双通道与一键部署。

Telegram 是个人 AI 助手的天然载体:免费、全球可达、Bot API 成熟、支持推送。eve 把 Telegram 作为移动端的主动触达通道,Web 端作为主要交互界面,两者共享同一套记忆库和会话状态。容易被低估的是一键部署 Builder:填好 API key 和偏好就能复刻一个配置好的助手实例。往深了想,这是“助手即模板”的思路——类似 GPTs,但完全开源可控,开发者甚至可以给团队每个人配一个懂业务流程的助手。

最后下个判断,不和稀泥。

为什么这类项目值得关注?因为自托管等于数据主权。用商业 AI 助手,你的所有对话、偏好、日程都在别人的服务器上;而助手的记忆越丰富、越“懂你”,数据敏感度就越高——记忆越有价值,自托管就越必要。这是“个人 AI 助理”这个场景下几乎必然的终局选择。

同时,当前 Agent 热潮集中在工具调用和任务执行,但真人助理最有价值的时刻,往往不是你提问时,而是 TA 主动提醒你“半小时后有个会”。主动 reminders 正是在补这块拼图。

留一个开放问题:记忆的衰减与合并机制怎么设计,才不会膨胀成噪音堆?主动触达的打扰边界又在哪里——提醒太频烦,助手感就变成了骚扰感。这两个问题,eve 还没有给出答案,但至少它把问题正确地摆上了台面。12 stars 的项目指出了大厂没做的事,这就是它值得被认真讨论的理由。


来源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve)

原文:https://www.rainbowonionai.cn/energyboytweve.html

12 stars 的开源项目冲上 GitHub Trending:这个叫 eve 的助手,让 AI 第一次主动开口找你

你关掉 ChatGPT 窗口,它就“消失”了。不记得你昨天的 deadline,不会在开会前给你发一条 Telegram。GitHub 上一个叫 eve 的开源项目(EnergyBoyTW/eve),正在补上这块缺口:常驻运行、长期记忆、主动发消息。

配图

12 stars,凭什么上 Trending?

先说清楚底细:eve 目前只有 12 stars,还处于早期阶段。但它登上了 GitHub Trending,说明这个方向戳中了很多人的痛点。

痛点是什么?现在的 AI 助手永远是“你问我答”。它缺的不是一个更聪明的模型,而是三个能力维度:

1. 常驻性(Always-on):持续运行,不是按需唤醒

2. 长期记忆:跨会话记住你的偏好、历史对话、重要事项

3. 主动性(Proactive):基于时间或规则主动触达你

问什么答什么,那叫搜索框。真人助理最值钱的时刻,是你还没开口,TA 先说“半小时后有个会”。

四大模块怎么搭起来的

eve 的架构可以拆成四块,每块都在解决“助手感”问题:

一、Web + Telegram 双通道。 Web 聊天是主要交互界面,Telegram Bot 负责移动端的主动触达。两者共享同一个记忆库和会话状态——你在网页上说过的话,Telegram 那边照样记得。Telegram 被选为推送通道不奇怪:免费、全球可达、Bot API 成熟。 二、长期记忆库。 这里有个常见误区:很多项目的“记忆”就是把聊天记录一股脑塞进 context。合格的长期记忆至少要三步——从对话中提取值得持久化的信息、用 embedding 向量化存入数据库、新对话到来时检索相关记忆注入 prompt。生产环境一般用 Chroma、Qdrant、pgvector 这类向量数据库,而且必须加记忆衰减和合并机制,否则记忆库迟早膨胀成噪音堆。

核心逻辑用一段极简代码就能说清:

from dataclasses import dataclass
import numpy as np

@dataclass
class Memory:
    content: str
    embedding: np.ndarray
    timestamp: str
    importance: float  # 重要度评分,用于遗忘/筛选

class LongTermMemory:
    def __init__(self, embed_fn, threshold=0.75):
        self.memories: list[Memory] = []
        self.embed = embed_fn
        self.threshold = threshold

![配图](/images/drafts/img-b15519d8c6531f.jpg)

    def remember(self, text: str, ts: str):
        """对话结束后提取值得记住的信息"""
        emb = self.embed(text)
        # 去重:与已有记忆相似度过高则跳过
        for m in self.memories:
            if float(np.dot(m.embedding, emb)) > self.threshold:
                return
        self.memories.append(Memory(text, emb, ts, importance=0.5))

    def recall(self, query: str, top_k: int = 5) -> list[str]:
        """新对话到来时,召回相关记忆注入上下文"""
        q = self.embed(query)
        scored = sorted(
            self.memories,
            key=lambda m: np.dot(m.embedding, q) + m.importance * 0.3,
            reverse=True,
        )
        return [m.content for m in scored[:top_k]]

注意去重和重要度评分这两个细节——记忆系统不做筛选,等于没做。

三、主动提醒调度器。 这是 eve 最有意思的部分。技术上是一个后台常驻循环:到点检查任务,触发时不是机械转发“您有一个提醒”,而是让 LLM 结合记忆和上下文生成自然语言。“助手感”和“闹钟感”的区别就在这一步。

import asyncio
from datetime import datetime

class ProactiveScheduler:
    """后台常驻任务:到点主动通过 Telegram 推送消息"""
    def __init__(self, tg_bot, llm):
        self.tg_bot = tg_bot
        self.llm = llm
        self.reminders = []  # (触发时间, 用户指令上下文)

    def add(self, when: datetime, user_intent: str):
        self.reminders.append((when, user_intent))

    async def run(self):
        while True:
            now = datetime.now()
            due = [r for r in self.reminders if r[0] <= now]
            for when, intent in due:
                # 不是机械转发,而是让 LLM 结合记忆组织提醒语
                msg = await self.llm.generate(
                    f"现在是 {when},用户之前要求:{intent}。"
                    f"请生成一条自然、简洁的主动提醒。"
                )
                await self.tg_bot.send(msg)
                self.reminders.remove((when, intent))
            await asyncio.sleep(30)

四、一键部署 Builder。 这个功能最容易被低估,但可能是最有想象力的:填好 API key 和偏好,就能生成一个配置好的复刻实例。对开发者来说,这意味着可以把“定制助手”当产品分发——给团队每个人配一个懂业务流程的助手。文章把它类比为 “GPTs 但完全开源可控”,相当贴切。

【配图建议:深夜书桌前亮着的电脑屏幕,屏幕上是聊天界面】

为什么值得你自己部署一套?

答案就两个字:数据主权。

用商业 AI 助手,你的对话、偏好、日程全在别人服务器上。而 eve 这类自托管方案,记忆数据完全握在自己手里。关键是——AI 助手越“懂你”,数据敏感度就越高。记忆越有价值,自托管就越必要。这不是偏执,是账要算清楚。

更深一层看,当前的 Agent 热潮都挤在“工具调用”和“任务执行”上,但个人助理场景里,时间维度上的主动性可能才是落地的关键拼图。eve 正是在补这一块——虽然它只有 12 stars,架构却相当完整,对想动手的个人开发者是很好的参考。

问题来了:你会放心让 AI 掌握你的日程和偏好数据吗?自托管的 eve,和便利的商业助手,你选哪个?评论区聊聊。


来源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve)

原文:https://www.rainbowonionai.cn/energyboytweve.html

睡过头时第一个给你发消息的不是老板,是你自己部署的 AI 助手。GitHub Trending 上的开源项目 eve(EnergyBoyTW/eve),目前才 12 stars,但思路很野:让 AI 常驻运行、跨会话记住你说过的话,还会主动通过 Telegram 给你发消息。

关键是提醒不是闹钟式的“您有一条提醒”,而是让 LLM 结合记忆和上下文,用自然语言开口。而且它是自托管开源,越“懂你”的记忆数据都握在自己手里,还内置一键部署 Builder,能复刻给团队每人一个。

你愿意让 AI 先开口找你吗?#AI助手# #开源项目# #Agent#


来源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve)

原文:https://www.rainbowonionai.cn/energyboytweve.html

🎬 本机管线自动渲染成片(未发布,人工审片前仅供参考)

【视频脚本总览】总时长 95 秒 | 横屏 16:9 | 定位:用 90 秒讲清一个 12 stars 的开源项目,如何让 AI 助手从“你问我答”变成会主动找你

【分镜 1|开场钩子|0-5秒】

画面:ChatGPT 窗口点关闭,屏幕瞬间黑屏,配“啪”一声关机音效

口播:你的 ChatGPT 关掉窗口就“死”了——但 GitHub 上一个只有 12 stars 的开源项目,会让 AI 主动给你发消息:半小时后有个会。

字幕:12 stars,却把 AI 助手做“活”了

【分镜 2|背景铺垫|5-25秒】

画面:动画演示“打开才醒来、关掉就消失”的循环,三个关键词逐个弹出

口播:现在的 AI 助手有个根本问题:没有存在感。你不问,它永远沉默。它不记得你昨天说的项目 deadline,更不会在你睡过头时主动发一条 Telegram 消息。GitHub 趋势榜上的开源项目 eve,作者 EnergyBoyTW,就是冲着三个缺失维度来的:常驻性、长期记忆、主动性。

字幕:常驻性 / 长期记忆 / 主动性

【分镜 3|核心解析|25-60秒】

画面:eve 六大能力清单逐条弹出;切到“记忆写入→向量化→召回”流程动画

口播:先看长期记忆。大多数项目就是把聊天记录一股脑塞进上下文——那是复读机,不是记忆。正确做法是三步:从对话里提取值得记住的偏好、事实、待办;用 embedding 向量化存起来;新对话到来时,召回相关记忆注入提示词。生产环境要上向量数据库,比如 Chroma、Qdrant、pgvector,还得加记忆衰减和合并,不然记忆库会膨胀成噪音堆。再说最有意思的:主动提醒。后台调度器常驻运行,到点就通过 Telegram Bot 主动推消息——弹幕互动点见分镜尾。

字幕:记忆≠聊天记录 / 主动提醒 = 调度器 + 消息通道

【分镜 4|延伸对比|60-85秒】

画面:左右分屏对比:“您有一个提醒”模板推送 vs LLM 结合记忆生成的自然语言提醒

口播:注意关键设计:提醒不是模板化的“您有一个提醒”,而是让大模型结合记忆和上下文,生成一句自然的话。这才是“助手感”和“闹钟感”的区别。另外两个点:Telegram 双通道,Web 端和 Bot 共享同一个记忆库;还有个被低估的一键部署 Builder,能把配置好的助手实例一键复刻——本质是“助手即模板”,类似 GPTs,但完全开源可控。

字幕:助手感 vs 闹钟感 / Assistant-as-Template

【分镜 5|总结+三连|85-100秒】

画面:回到 eve 仓库页面,12 stars 数字特写,最后一帧打字机效果出金句

口播:它才 12 stars,还在早期,但架构已经相当完整。而自托管意味着一件事:你的 AI 越“懂你”,数据越敏感,记忆越有价值,就越要握在自己手里。如果你也想亲手拆这套架构,三连收藏,下期带你看它的主动提醒调度器怎么写。

字幕:12 stars → 架构完整 / 数据主权 = 自托管的理由

【弹幕互动点】

1. 分镜 3 结尾:你想让 AI 主动提醒你什么?把答案打在公屏上——开会?deadline?还是叫你起床?

2. 分镜 4 结尾:觉得“主动性”才是 AI 助手真正缺的那块拼图的,打 1;觉得还是隐私优先的,打 2。

【BGM与节奏】

全片用节奏感强的电子底鼓类 BGM(参考 technology/minimal vlog 风格),开场 0-5 秒音量压低突出口播,分镜 3、4 关键词弹出时卡鼓点;分镜 5 收尾 BGM 渐弱,留白给三连引导。剪辑节奏:每 5-8 秒切一次画面或弹关键词,避免静止。

【素材清单】

1. 屏幕录制:ChatGPT 关闭窗口黑屏(开场)

2. 屏幕录制:GitHub 上 EnergyBoyTW/eve 仓库页面,特写 12 stars 与 Trending 标识

3. 动画素材:三大能力维度关键词(常驻性/长期记忆/主动性)逐条弹出

4. 流程动画:记忆“提取→向量化→检索召回”三步图

5. 分屏对比素材:模板推送 vs 自然语言提醒

6. 【配图建议:手机接收 Telegram 推送消息的特写画面,营造“AI 主动找你”的场景感】

7. 【配图建议:深夜工作台场景,呼应“数据主权”与个人自托管的氛围】


来源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve)

原文:https://www.rainbowonionai.cn/energyboytweve.html

【视频脚本总览】总时长 45-60 秒 | 竖屏 9:16 | 一句话定位:一个才 12 个 star 的开源项目,让你的 AI 助手第一次主动给你发消息。

【分镜 1|0-3秒|利益点开场】

画面:手机屏幕特写,用户对着微信 AI 对话框打字,然后切黑屏配大字“它记不住你”。

口播:你手机上的 AI 助手就是个金鱼——你问它才答,你关它就“死”,昨天说的话今天全忘。

字幕:AI 助手 = 金鱼记忆?

【分镜 2|3-30秒|正文讲清】

画面:GitHub 项目页录屏,滚到 eve 的 README,标出"Always-on""Telegram""长期记忆"几个关键词,红圈高亮。

口播:GitHub 上有个开源项目叫 eve,现在才 12 个 star,早期阶段,但想法很猛。它给 AI 补了三样东西:一是常驻运行,不用等你打开才醒;二是长期记忆,跨会话记得你说过的话、你的偏好;三是最狠的——主动发消息找你。比如你该开会了,它通过 Telegram 自己给你推一条提醒。关键是这提醒不是"您有一个提醒"那种死板模板,是 AI 结合记忆自己组织的话术,这才叫助手,不叫闹钟。而且它是开源自托管,聊天记录和记忆数据全存你自己手里,不用交给大厂。

字幕:常驻运行 / 长期记忆 / 主动找你 / 数据在自己手里

【分镜 3|30-45秒|实在收尾】

画面:镜头切回真人出镜,举起手机做出发消息的动作,字幕弹出提问。

口播:它还内置一键部署,配置好就能复刻一个自己的助手。问题来了——你敢不敢让 AI 主动管你?想要的评论区扣个"助手",我把项目名放评论区置顶。

字幕:敢让 AI 主动管你吗?扣"助手"

【BGM与节奏】前 3 秒用低沉鼓点制造悬念,讲到"主动发消息"处切明快节奏;语速中快,分镜 2 信息密但不赶,结尾放慢留互动空间。

【素材清单】

【配图建议:手机 AI 对话界面黑屏大字"它记不住你"】

【配图建议:GitHub eve 项目页录屏,README 关键词红圈高亮】

【配图建议:Telegram 收到主动提醒消息的模拟弹窗】

【配图建议:真人出镜举手机口播收尾画面】


来源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve)

原文:https://www.rainbowonionai.cn/energyboytweve.html

12 stars 的开源项目 eve:让 AI 助手关掉窗口也能“活着”,还会主动给你发 Telegram

你的 AI 助手有一个根本性缺陷:你打开 ChatGPT,它才“醒来”;你关掉窗口,它就“消失”。它不记得你昨天说的项目 deadline,更不可能主动给你发一条消息。GitHub Trending 上的开源项目 eve(EnergyBoyTW/eve)正在解决这个问题——它目前只有 12 stars,处于早期阶段,但围绕“AI 助手该有的三个维度”给出了相当完整的架构设计。

【配图建议:开发者深夜对着终端屏幕与聊天界面的氛围图】

一、范式缺失:AI 助手的三个“没有”

现在的 AI 对话能力爆炸式提升,但 eve 的作者指出三个能力维度普遍缺失:

1. 常驻性(Always-on):助手持续运行,而非按需唤醒

2. 长期记忆(Long-term Memory):跨会话记住偏好、历史对话和重要事项

3. 主动性(Proactive):基于时间、事件或规则主动触达用户

这三个维度不是并列的功能点,而是递进的:没有常驻就没有记忆的持续积累,没有记忆的主动性就是无意义的定时推送。eve 的六大核心能力——Web 聊天界面、Telegram Bot 集成、主动提醒、长期记忆、应用集成、一键部署 Builder——全部挂在这三条主线上。

二、长期记忆:把“聊天记录”变成“记忆系统”

大多数项目的所谓“记忆”,就是把对话历史一股脑塞进 context。一个合格的长期记忆系统至少需要三步:记忆提取(识别值得持久化的偏好、事实、待办)、向量化存储(embedding 存入向量数据库)、相关性检索(新对话到来时召回相关记忆注入 prompt)。

原文给出的实现思路值得细看——注意去重阈值 0.75、召回 top_k=5、重要度加权 0.3 这几个参数的设计:

from dataclasses import dataclass
import numpy as np

@dataclass
class Memory:
    content: str
    embedding: np.ndarray
    timestamp: str
    importance: float  # 重要度评分,用于遗忘/筛选

class LongTermMemory:
    def __init__(self, embed_fn, threshold=0.75):
        self.memories: list[Memory] = []
        self.embed = embed_fn
        self.threshold = threshold

    def remember(self, text: str, ts: str):
        """对话结束后提取值得记住的信息"""
        emb = self.embed(text)
        # 去重:与已有记忆相似度过高则跳过
        for m in self.memories:
            if float(np.dot(m.embedding, emb)) > self.threshold:
                return
        self.memories.append(Memory(text, emb, ts, importance=0.5))

    def recall(self, query: str, top_k: int = 5) -> list[str]:
        """新对话到来时,召回相关记忆注入上下文"""
        q = self.embed(query)
        scored = sorted(
            self.memories,
            key=lambda m: np.dot(m.embedding, q) + m.importance * 0.3,
            reverse=True,
        )
        return [m.content for m in scored[:top_k]]

三个设计点:写入时用余弦相似度去重,避免同一句话被存一百遍;召回时给重要度乘 0.3 的权重叠加到相似度上,让“重要但没那么相关”的记忆也有机会被召回;Memory 结构体里预留 importance 字段,为遗忘机制留接口。

生产化提示:self.memories 应替换为向量数据库(如 Chroma、Qdrant、pgvector),并加上记忆衰减和合并机制——否则记忆库会膨胀成噪音堆。

三、主动提醒:让 AI 第一次“主动开口”

这是 eve 最有意思的部分。技术上,主动触达 = 后台调度器 + 消息通道。原文基于 asyncio 的实现:

import asyncio
from datetime import datetime

class ProactiveScheduler:
    """后台常驻任务:到点主动通过 Telegram 推送消息"""
    def __init__(self, tg_bot, llm):
        self.tg_bot = tg_bot
        self.llm = llm
        self.reminders = []  # (触发时间, 用户指令上下文)

    def add(self, when: datetime, user_intent: str):
        self.reminders.append((when, user_intent))

    async def run(self):
        while True:
            now = datetime.now()
            due = [r for r in self.reminders if r[0] <= now]
            for when, intent in due:
                # 不是机械转发,而是让 LLM 结合记忆组织提醒语
                msg = await self.llm.generate(
                    f"现在是 {when},用户之前要求:{intent}。"
                    f"请生成一条自然、简洁的主动提醒。"
                )
                await self.tg_bot.send(msg)
                self.reminders.remove((when, intent))
            await asyncio.sleep(30)

关键不在轮询本身,而在触发后的处理:提醒消息不是模板化的“您有一个提醒”,而是让 LLM 结合记忆和上下文生成自然语言。这是“助手感”和“闹钟感”的区别——也是这类项目能否真正有用的分水岭。

四、双通道架构与被低估的 Builder

通道选择上,Telegram 是个人 AI 助手的天然载体:免费、全球可达、Bot API 成熟、支持推送。eve 的分工很清晰:Telegram 做移动端的主动触达通道,Web 做主要交互界面,两者共享同一个记忆库和会话状态。这意味着你在 Web 上说的偏好,Telegram 端的主动提醒能用上。

一键部署 Builder 常被忽视,但它的意义有三层:对个人用户,填好 API key 和偏好即可获得自己的助手;对开发者,可以把“定制助手”作为产品分发给团队每个人;对生态,这实际是“助手即模板”(Assistant-as-Template)的思路——类似 GPTs,但完全开源可控。

【配图建议:代码编辑器与架构草图同框的技术感画面】

五、对开发者的两个实践判断

第一,自托管 = 数据主权。 用商业 AI 助手,你的所有对话、偏好、日程都在别人服务器上。而 AI 助手越来越“懂你”的过程,就是数据敏感度攀升的过程——记忆越有价值,自托管就越必要。eve 这类开源自托管方案,记忆数据完全在自己手里。 第二,“主动性”是 Agent 落地的关键拼图。 当前 Agent 热潮集中在工具调用和任务执行,但真正的个人助理场景中,时间维度上的主动性可能更重要。你的真人助理最有价值的时刻,往往不是你提问时,而是 TA 主动提醒你“半小时后有个会”的时候。 给你的行动建议:eve 只有 12 stars,正适合 Fork 下来当架构参考读。哪怕不直接用,把“提取 → 向量化 → 召回”的记忆管线和一个 asyncio 调度器搬进自己的 Agent 项目,成本极低,体感提升明显——这是本周就能动手的事。

来源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve)

原文:https://www.rainbowonionai.cn/energyboytweve.html

12 stars 的开源项目 eve:把个人 AI 助手缺的三块拼图先画完整了

你的 ChatGPT 关掉窗口就“死”了——不记得昨天的对话,不会在你开会前主动发消息。GitHub 上一个叫 eve 的项目(EnergyBoyTW/eve),正在补这块拼图:一个 always-on、有长期记忆、会主动找你的个人 AI 助手。

它还处在早期阶段,目前 12 stars。但架构完整度值得开发者扒一扒,正好来自 GitHub Trending。

一、它补的是哪三块拼图?

现在的 AI 助手普遍缺三个维度:

1. 常驻性:不是按需唤醒,而是持续运行

2. 长期记忆:跨会话记住偏好、历史和待办

3. 主动性:基于时间或事件主动触达,而不是等你问

eve 的六大模块直接对着这三个维度设计:Web 聊天界面、Telegram Bot、主动提醒、长期记忆、应用集成、一键部署 Builder。整体链路是多端接入 → 核心引擎统一调度(always-on + 意图路由)→ 记忆库和主动提醒调度器做支撑。

二、技术拆解:记忆和主动性怎么做才对

记忆不是把聊天记录塞进 context。 合格的长期记忆至少三步:从对话里提取值得持久化的信息(偏好、事实、待办),embedding 后存入向量库,新对话到来时按相关性检索注入 prompt。一个典型的写入与召回实现:

from dataclasses import dataclass
import numpy as np

@dataclass
class Memory:
    content: str
    embedding: np.ndarray
    timestamp: str
    importance: float  # 重要度评分,用于遗忘/筛选

class LongTermMemory:
    def __init__(self, embed_fn, threshold=0.75):
        self.memories: list[Memory] = []
        self.embed = embed_fn
        self.threshold = threshold

    def remember(self, text: str, ts: str):
        """对话结束后提取值得记住的信息"""
        emb = self.embed(text)
        # 去重:与已有记忆相似度过高则跳过
        for m in self.memories:
            if float(np.dot(m.embedding, emb)) > self.threshold:
                return
        self.memories.append(Memory(text, emb, ts, importance=0.5))

    def recall(self, query: str, top_k: int = 5) -> list[str]:
        """新对话到来时,召回相关记忆注入上下文"""
        q = self.embed(query)
        scored = sorted(
            self.memories,
            key=lambda m: np.dot(m.embedding, q) + m.importance * 0.3,
            reverse=True,
        )
        return [m.content for m in scored[:top_k]]

注意这里的去重阈值 0.75、top_k=5、重要度权重 0.3 都是示例参数,但机制是通用的:相似度过高就跳过写入,检索时用相关性加上重要度加权排序。生产环境要把内存 list 换成 Chroma、Qdrant 或 pgvector,再加记忆衰减和合并机制——否则记忆库会膨胀成噪音堆。

主动提醒的本质是“后台调度器 + 消息通道”。 核心逻辑是一个常驻循环,每 30 秒轮询一次到期的提醒,然后通过 Telegram 推送:

import asyncio
from datetime import datetime

class ProactiveScheduler:
    """后台常驻任务:到点主动通过 Telegram 推送消息"""
    def __init__(self, tg_bot, llm):
        self.tg_bot = tg_bot
        self.llm = llm
        self.reminders = []  # (触发时间, 用户指令上下文)

    def add(self, when: datetime, user_intent: str):
        self.reminders.append((when, user_intent))

    async def run(self):
        while True:
            now = datetime.now()
            due = [r for r in self.reminders if r[0] <= now]
            for when, intent in due:
                # 不是机械转发,而是让 LLM 结合记忆组织提醒语
                msg = await self.llm.generate(
                    f"现在是 {when},用户之前要求:{intent}。"
                    f"请生成一条自然、简洁的主动提醒。"
                )
                await self.tg_bot.send(msg)
                self.reminders.remove((when, intent))
            await asyncio.sleep(30)

关键设计点:提醒语不是模板化的“您有一个提醒”,而是让 LLM 结合记忆和上下文生成自然语言。这是“助手感”和“闹钟感”的区别。选 Telegram 也有讲究——免费、全球可达、Bot API 成熟、支持推送,天然适合做移动端主动触达通道;Web 端做主交互界面,两边共享同一个记忆库和会话状态。

一键部署 Builder 是被低估的设计。 它能把配置好的助手实例一键复刻,实际是“Assistant-as-Template”的思路:个人用户填好 API key 和偏好就能拿到自己的助手;开发者可以把定制助手当产品分发给团队,给每个人配一个懂业务流程的版本。类似 GPTs,但完全开源可控。

三、对日常开发的启示

自托管 = 数据主权。 商业 AI 助手里,你的对话、偏好、日程都在别人服务器上。而助手越“懂你”,记忆数据的敏感度越高——记忆越有价值,自托管就越必要。eve 这类方案让数据留在自己手里。 主动性可能是 Agent 落地的关键拼图。 现在的 Agent 热潮集中在工具调用和任务执行,但真人助理最有价值的时刻,往往不是你提问时,而是 TA 主动提醒你“半小时后有个会”。下次做自己的 AI 项目时,先想想:除了被动响应,时间维度上的主动触达要不要一起设计进去?

12 stars 不代表没价值——有些项目是先在架构上把问题想清楚了,剩下的交给时间。可以去仓库跑一遍,重点关注它的记忆库和调度器的真实实现。


来源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve)

原文:https://www.rainbowonionai.cn/energyboytweve.html

AI助手为什么不会主动找你?这个GitHub项目eve给出了答案

AI助手永远“你问我答”的根源在于:你打开ChatGPT它才“醒来”,关掉窗口它就“消失”。而GitHub上EnergyBoyTW的开源项目eve,正在补上这块缺口——一个真正“always-on”、有长期记忆、还会主动通过Telegram给你发消息的个人AI助手。

配图

缺的不是智力,是三样东西

过去两年AI对话能力突飞猛进,但助手的根本问题没解决:没有“存在感”。它不记得你昨天说的项目deadline,更不可能在你睡过头时主动提醒你。

具体来说,是三个能力维度的缺失:

1. 常驻性(Always-on):助手持续运行,而不是按需唤醒

2. 长期记忆:跨会话记住用户偏好、历史对话和重要事项

3. 主动性:基于时间、事件或规则主动触达用户

eve目前还在早期阶段,只有12个stars,但架构设计相当完整,对个人开发者极具参考价值。

【配图建议:手机屏幕上的聊天消息提醒界面特写】

eve的核心架构:四大能力模块

根据项目描述,eve的能力包括:Web聊天界面、Telegram Bot集成、主动提醒、长期记忆,另有应用集成和一键部署Builder。

配图 主动提醒是eve最有意思的部分。技术上,它靠一个后台常驻调度器加消息通道的组合实现。关键设计在于:提醒消息不是模板化的“您有一个提醒”,而是让LLM结合记忆和上下文生成自然语言——这才是“助手感”和“闹钟感”的区别。 长期记忆方面,一个合格的系统至少需要记忆提取、向量化存储、相关性检索三步。生产环境中可用Chroma、Qdrant、pgvector等向量数据库,并加上记忆衰减和合并机制——否则记忆库会膨胀成噪音堆。 双通道设计上,Telegram免费、全球可达、Bot API成熟,被用作移动端的“主动触达”通道;Web端作为主要交互界面。两者共享同一个记忆库和会话状态。

还有个被低估的功能:一键部署Builder。它可以把配置好的助手实例一键复刻——对个人用户,填好API key即可获得自己的助手;对开发者,可以把定制助手当产品分发给团队。这实际上就是“助手即模板”的思路,类似GPTs但完全开源可控。

【配图建议:开发者电脑上的代码编辑器与架构图并排画面】

为什么值得普通人关注?

一是数据主权。用商业AI助手,你的对话、偏好、日程都在别人服务器上。而当AI助手越来越“懂你”,记忆的敏感度就越高——记忆越有价值,自托管就越必要。

二是原文作者的观点:“主动性”是AI Agent落地的关键拼图。当前Agent热潮集中在工具调用和任务执行,但真人助理最有价值的时刻,往往是你提问时,而是TA主动提醒你“半小时后有个会”的时候。eve的proactive reminders正是在补这块拼图。

如果你也被“金鱼记忆”式AI折磨过,可以去GitHub搜“EnergyBoyTW/eve”看看源码,或者动手部署一个属于自己的常驻助手——你的第一条主动消息,可能就从那里开始。


来源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve)

原文:https://www.rainbowonionai.cn/energyboytweve.html

你的 AI 助手还在“金鱼记忆”?这个开源项目让 AI 第一次主动找上了我

早上十点,我在地铁上惊醒——半小时前有个会。而手机里那位“AI 助手”,安静得像没充电。

配图

它只会在我问它的时候醒着。

打开 ChatGPT,它才“醒来”;关掉窗口,它就“消失”。它不记得我昨天提过的项目 deadline,更不可能在我睡过头时,主动给我发一条 Telegram 消息。和它聊了几百次,它到现在还不记得我上周说过什么。

原来不是它笨,是我们默认了 AI 就该有“金鱼记忆”。

直到我在 GitHub Trending 上刷到一个叫 eve 的开源项目(EnergyBoyTW/eve)。说实话,我一开始没抱期待——它目前只有 12 stars,处于很早期的阶段。但点进去看完,我承认我被这个“小小的”项目打动了。因为它瞄准的,恰好是现有 AI 助手最根本的那个空洞:AI 没有“存在感”。

项目描述里写得很清楚,它要做的是 “Always-on 个人 AI 助手”,围绕三个维度构建:常驻性(持续运行,而不是按需唤醒)、长期记忆(跨会话记住你的偏好和事项)、主动性(基于时间和事件主动触达你,而不是被动等问)。

这三个词拆开看都不新鲜,合在一起却像是说出了我一直说不出的话。

【配图建议:深夜书桌上亮着的电脑屏幕,屏幕上是一个简洁的聊天界面】

先说主动提醒,这是最让我好奇的部分。

eve 的做法是后台调度器加消息通道的组合。有意思的不是调度本身,而是提醒语怎么来——它不是机械地转发“您有一个提醒”,而是让 LLM 结合记忆和上下文,生成一句自然的话。

“助手感”和“闹钟感”的区别,就在这一句话之间。

想象一下:闹钟只会吵醒你,而助手会知道你为什么需要被叫醒,甚至知道该怎么跟你说。技术上就一步之差,体验上是两个世界。

再说长期记忆。

大多数项目所谓的“记忆”,就是把对话历史一股脑塞进 context——本质上还是金鱼,只是鱼缸大一点。而一个合格的长期记忆系统,至少要做三件事:从对话中提取值得持久化的信息,用 embedding 向量化后存入向量数据库,新对话到来时再按相关性检索、注入 prompt。

生产环境中还得考虑记忆衰减和合并机制,否则记忆库会膨胀成一堆噪音。eve 这套设计让 Web 端和 Telegram 端共享同一个记忆库——你在电脑上说过的话,在地铁上用 Telegram 问它,它是接得住的。

第三个值得说的功能,反而最容易被忽略:一键部署 Builder。它可以把配置好的助手实例直接复刻,意味着你可以把“定制助手”当模板分发给团队里的每个人。这其实是“助手即模板”的思路,类似 GPTs,但完全开源可控。

【配图建议:地铁上低头看手机的人,屏幕微光映在脸上】

写到这,我想起一个更朴素的问题:我们凭什么要把越来越懂自己的 AI,交给别人的服务器?

用商业 AI 助手,你所有的对话、偏好、日程都存在别人那里。而 eve 这类自托管方案,记忆数据完全握在自己手里。你的助手越“懂你”,数据就越敏感——记忆越有价值,自托管就越必要。

还有一层更深的东西。现在 Agent 的热潮都集中在“工具调用”和“任务执行”,但真正的个人助理场景里,时间维度上的主动性可能更重要。你的真人助理最值钱的时刻,往往不是你提问的时候,而是 TA 主动提醒你“半小时后有个会”的时候。

eve 的 proactive reminders,正是在补这块拼图。

它现在只有 12 stars,也许三个月后就消失在 GitHub 的长河里。但那个方向是对的:AI 助手不该是一个你想起它才打开的窗口,而应该是一个一直醒着、记得你的事、会在恰当时候开口的存在。

今晚我准备把 eve 部署起来试试。你也一样——下次再对着一个“金鱼记忆”的 AI 重复自己说过的话时,不妨想想:也许问题不在你,在于我们一直在用错了范式。


来源:GitHub Trending - EnergyBoyTW/eve(https://github.com/EnergyBoyTW/eve)

原文:https://www.rainbowonionai.cn/energyboytweve.html

🚀 多平台发布

点击「复制」获取平台专属文案,到各平台编辑器(App/网页)粘贴即可发布。
有密钥的 4 个平台(微信服务号 / 头条 / 百家号 / 微博)可自动发布,密钥填好后自动点亮。

平台状态操作
💬 公众号🔑 待配置密钥
🎵 抖音📋 手动复制
📕 小红书📋 手动复制
🤔 知乎📋 手动复制
📰 今日头条🔑 待配置密钥
🐦 微博🔑 待配置密钥
📺 B站📋 手动复制
⚡ 快手📋 手动复制
💻 CSDN📋 手动复制
⛏️ 掘金📋 手动复制
📝 百家号🔑 待配置密钥
✍️ 简书📋 手动复制