2025-04-14 09:00:40
MCP 起源于 2024 年 11 月 25 日 Anthropic 发布的文章：Introducing the Model Context Protocol。
MCP 就是以更标准的方式让 LLM Chat 使用不同工具，这样应该更容易理解“中间协议层”的概念了。Anthropic 旨在实现 LLM Tool Call 的标准。
MCP （Model Context Protocol，模型上下文协议）定义了应用程序和 AI 模型之间交换上下文信息的方式。这使得开发者能够以一致的方式将各种数据源、工具和功能连接到 AI 模型（一个中间协议层），就像 USB-C 让不同设备能够通过相同的接口连接一样。MCP 的目标是创建一个通用标准，使 AI 应用程序的开发和集成变得更加简单和统一。
MCP 主解决的一个问题是：如何将 AI 模型和我们已有系统集成。
在跟 LLM 交互的时候，为了显著提升模型的能力需要提供更结构化的上下文信息，例如提供一些更具体、实时的信息（比如本地文件，数据库，一些网络实时信息等）给模型，这样模型更容易理解真实场景中的问题。想象一下没有 MCP 之前会怎么做？我们会人工从数据库中筛选或者使用工具检索可能需要的信息复制到 prompt 中，随着要解决的问题越来越复杂，人工参与这样的数据交互过程变得越来越难以实现。
许多 LLM 如 OpenAI、Google、Qwen 等引入了 function call 功能，这一机制允许模型在需要时调用预定义的函数来获取数据或执行操作显著提升了自动化水平，当前大热门 AI Agent 也具备类似的能力。那么 function calling、AI Agent、MCP 这三者之间有什么区别：
基于 AI 做编程和应用开发时，开发者都希望将数据、系统连接到模型的这个环节可以更智能、更统一。Anthropic 基于这样的痛点设计了 MCP，充当 AI 模型的「万能转接头」，让 LLM 能轻松的获取数据或者调用工具。更具体的说 MCP 的优势在于：
在深入学习 MCP 技术原理之前，为了能够对 MCP 比较有体感，可以先了解怎么使用 MCP。Claude Desktop 是比较早支持 MCP 协议的，但是由于众所周知的原因，在国内使用 Claude 并不方便，可以参考它的教程：For Claude Desktop Users - Model Context Protocol。
关于怎么使用 MCP，我打算以 OpenCat 为例介绍一下，如何采用 OpenCat + Qwen 组合使用 MCP：
MCP 遵循客户端-服务器架构（client-server），其中包含以下几个核心概念：
MCP client 充当 LLM 和 MCP server 之间的桥梁，MCP client 的工作流程如下：
MCP server 是 MCP 架构中的关键组件，它可以提供 3 种主要类型的功能：
这些功能使 MCP server 能够为 AI 应用提供丰富的上下文信息和操作能力，从而增强 LLM 的实用性和灵活性。
LLM 调用 MCP 的过程可以分为两个步骤：
为了更加深入理解 MCP 原理，我打算从 MCP 协议的源码进行分析：
根据 MCP 官方提供的 client example 进行源码分析，其中删除了一些不影响阅读逻辑的异常控制代码，通过阅读代码，可以发现模型是通过 prompt 来确定当前有哪些工具，通过将工具的具体使用描述以文本的形式传递给模型，供模型了解有哪些工具以及结合实时情况进行选择，具体情况可以参考代码中的注释：
###################
# 此处省略无关的代码 #
###################
async def start(self):
# 1.初始化所有的 mcp server
for server in self.servers:
await server.initialize()
# 2.获取所有的 tools 命名为 all_tools
all_tools = []
for server in self.servers:
tools = await server.list_tools()
all_tools.extend(tools)
# 3.将所有的 tools 的功能描述格式化成字符串供 LLM 使用，tool.format_for_llm() 我放到了这段代码最后，方便阅读。
tools_description = "\n".join(
[tool.format_for_llm() for tool in all_tools]
)
# 4.基于 prompt 和当前所有工具的信息询问 LLM（Qwen）应该使用哪些工具。
system_message = (
"You are a helpful assistant with access to these tools:\n\n"
f"{tools_description}\n"
"Choose the appropriate tool based on the user's question. "
"If no tool is needed, reply directly.\n\n"
"IMPORTANT: When you need to use a tool, you must ONLY respond with "
"the exact JSON object format below, nothing else:\n"
"{\n"
' "tool": "tool-name",\n'
' "arguments": {\n'
' "argument-name": "value"\n'
" }\n"
"}\n\n"
"After receiving a tool's response:\n"
"1. Transform the raw data into a natural, conversational response\n"
"2. Keep responses concise but informative\n"
"3. Focus on the most relevant information\n"
"4. Use appropriate context from the user's question\n"
"5. Avoid simply repeating the raw data\n\n"
"Please use only the tools that are explicitly defined above."
)
messages = [{"role": "system", "content": system_message}]
while True:
# 5.将用户输入消息进行聚合
messages.append({"role": "user", "content": user_input})
# 6.将 system_message 和用户消息输入一起发送给 LLM
llm_response = self.llm_client.get_response(messages)
# ...
class Tool:
"""Represents a tool with its properties and formatting."""
def __init__(
self, name: str, description: str, input_schema: dict[str, Any]
) -> None:
self.name: str = name
self.description: str = description
self.input_schema: dict[str, Any] = input_schema
# 把工具的名字 / 工具的用途（description）和工具所需要的参数（args_desc）转化为文本
def format_for_llm(self) -> str:
"""Format tool information for LLM.
Returns:
A formatted string describing the tool.
"""
args_desc = []
if "properties" in self.input_schema:
for param_name, param_info in self.input_schema["properties"].items():
arg_desc = (
f"- {param_name}: {param_info.get('description', 'No description')}"
)
if param_name in self.input_schema.get("required", []):
arg_desc += " (required)"
args_desc.append(arg_desc)
return f"""
Tool: {self.name}
Description: {self.description}
Arguments:
{chr(10).join(args_desc)}
还有一个地方需要分析清楚即 Tool 的描述和代码中的 input_schema 是怎么获取的？这个问题需要看一下 MCP 协议的实现（这里我分析的是 Python SDK 源代码），MCP Python SDK 使用装饰器 @mcp.tool() 来装饰函数时，对应的 name 和 description 等其实直接源自用户定义函数的函数名以及函数的 docstring 等，源代码如下：
@classmethod
def from_function(
cls,
fn: Callable,
name: str | None = None,
description: str | None = None,
context_kwarg: str | None = None,
) -> "Tool":
"""Create a Tool from a function."""
func_name = name or fn.__name__ # 获取函数名
if func_name == "<lambda>":
raise ValueError("You must provide a name for lambda functions")
func_doc = description or fn.__doc__ or "" # 获取函数 docstring
is_async = inspect.iscoroutinefunction(fn)
... # 更多请参考原始代码...
可以看出 LLM 使用工具是通过 prompt engineering，即提供所有工具的结构化描述和 few-shot 的 example 来确定该使用哪些工具。另一方面，大模型厂商（如Qwen）肯定做了专门的训练，确保大模型更能理解工具的 prompt 以及输出结构化的 tool call json 代码。
工具的执行就比较简单和直接，把 system prompt（指令与工具调用描述）和用户消息一起发送给模型，然后接收模型的回复。当模型分析用户请求后，它会决定是否需要调用工具：
如果回复中包含结构化 JSON 格式的工具调用请求，则客户端会根据这个 json 代码执行对应的工具。具体的实现逻辑都在 {python} process_llm_response 中，代码，逻辑非常简单。
如果模型执行了 tool call，则工具执行的结果 result 会和 system prompt 和用户消息一起重新发送给模型，请求模型生成最终回复。
如果 tool call 的 json 代码存在问题或者模型产生了幻觉怎么办呢？通过阅读代码发现，我们会 skip 掉无效的调用请求。
执行相关的代码与注释如下：
async def start(self):
# 省略无关的代码
while True:
# 假设这里已经处理了用户消息输入.
messages.append({"role": "user", "content": user_input})
# 获取 LLM 的输出
llm_response = self.llm_client.get_response(messages)
# 处理 LLM 的输出（如果有 tool call 则执行对应的工具）
result = await self.process_llm_response(llm_response)
# 如果 result 与 llm_response 不同，说明执行了 tool call （有额外信息了）
# 则将 tool call 的结果重新发送给 LLM 进行处理。
if result != llm_response:
messages.append({"role": "assistant", "content": llm_response})
messages.append({"role": "system", "content": result})
final_response = self.llm_client.get_response(messages)
logging.info("\nFinal response: %s", final_response)
messages.append(
{"role": "assistant", "content": final_response}
)
# 否则代表没有执行 tool call，则直接将 LLM 的输出返回给用户。
else:
messages.append({"role": "assistant", "content": llm_response})
结合这部分原理分析：
我开源了一个 MCP Repo，以 OpenCat 为 MCP Host，支持 Weather 数据查询的 MCP Server 和 MCP Client（[email protected]/edonyzpc/MCP.git）。
MCP Server 的开发可以参考 Server 章节：MCP/servers/weather-server-mcp
MCP Client 的开发可以参考 Client 章节：MCP/clients/mcp-client
MCP的初学者还缺少两部分：1. MCP的来龙去脉；2.MCP协议的观测和调试。篇幅限制，留待下次分解，Stay Tuned
2025-04-13 17:33:07
允许一切如其所是，也允许一切事与愿违
如果你没有按你真正想要的那种方式去生活,你的灵魂每天都会喊疼
成熟的重要标志是拥有翻篇的能力。
谁能给你带来最多的平静，谁就应该得到你最多的时间。
命运选择给某某好运气,并不一定是他有多优秀,而是他在遇到问题时，没有躲。
行动是产生结果的唯一方式,可惜的是,大多数人在“想”的过程中就已经消耗了100%的精力。
失败不是成功之母,成功才是成功之母。
不要依赖别人灌输给你的想法和观念去生活,不要遵循别人设计好的软件使用习惯去应用,也不要沉迷于通过消费、娱乐来获取多巴胺。
我们无法在消极的想法里活出积极的人生,也无法在拧巴的状态中活出通透的人生
很多事情做不成,缺的不是时间和机会,而是专心致志。
如果道路本身很美，不要问它通往何方。——要做过程热爱、有生命力的事情
"累了就躺一躺，不丢人“——雷军老师 68 17
原文链接：《📖人一旦开了窍，人生就开了挂》书摘 允许一切如其所是， - 即刻App
很多事情确实经历过一遍以后，再经历就很从容了。每一段过往都是成长的养料，我们要努力做的就是尽可能从中汲取足够多的营养。
原文链接：很多事情确实经历过一遍以后，再经历就很从容了。每一段过往都是 - 即刻App
有个事儿挺有意思的。
我们平时走在路上，看到陌生人，如果没什么事是并不会主动打招呼的对吧？每天有无数人擦肩而过。
但我有个狗。我有个狗呢，事情就发生了一些变化。带狗出门，迎面碰上的人有30%会看着我的狗，说哈喽。
我也不例外。外出看到狗，我也会情不自禁说：小狗！
和陌生人打招呼会很奇怪，但和陌生狗不会。
在一些场景下，人常说的人不如狗，或者人比狗狗，是不是也是错把投射当真实呢？
哈！既渴望连接又恐惧接触的城市穴居人呐。
原文链接：有个事儿挺有意思的。 我们平时走在路上，看到陌生人，如果没 - 即刻App
现在，很多人都对 AI 抱着一个幻想：我可能不是很专业，但如果借助 AI，不就能轻松变成专业人士了吗？确实，AI 在某些方面给了我们这样的错觉，比如稍微懂一点编程的人，可以轻松地用 AI 写出一个小程序的原型；不怎么懂设计的人，可以通过 AI 快速生成看起来不错的海报。然而，这种“什么都懂一点”再靠 AI 加持就能变专业的想法，其实是一种误解，甚至可能是一种危险的误解。
从根本上讲，AI 工具对用户的帮助主要集中在两个方面：
1. 提升能力的下限 什么叫“能力的下限”？就是说，以前一个完全不懂绘画的人根本画不出东西，现在借助 AI，可以迅速生成一幅看起来还不错的插画。原本根本不会写代码的人，也能通过 AI 生成基础的网页代码，实现简单的功能。这就是 AI 提高了普通人甚至零基础人士入门门槛的作用。
2. 提升专业人士的效率 如果你本来就是某个领域的专家，比如一个资深的软件开发者或者专业的医疗研究人员，那么 AI 的作用就更明显了。它能自动化大量重复性的工作，帮你快速生成需要反复编写的基础代码或自动整理医疗数据的初步报告，让你能把更多的时间和精力集中在真正需要人类思考和决策的核心工作上。这种情况下，AI 的价值是巨大的，它不仅提升了效率，还能让你原本就高水平的专业能力得到更大化的发挥。
原因主要在于 AI 自身的特性和使用者的水平局限：
AI（特别是像 ChatGPT 这样的大语言模型）生成的结果存在着“幻觉”（hallucination），通俗点说就是“胡编乱造”的问题。哪怕 AI 在 99% 的情况下都生成正确且高质量的结果，但只要有 1% 的错误或低质量结果，对于一些容错率极低的领域来说，比如医疗、法律或财务领域，都可能造成严重甚至致命的后果。
举个简单的例子：
因此，专业人士对 AI 生成结果的审核和判断极为关键，而非专业人士根本不具备这种审核能力。
对于某个专业领域，我们可以简单用 0 到 100 的分数来表示一个人的专业水平：
当非专业人士使用 AI 时，即便 AI 能帮助他实现 60-80 分的效果，这个人实际上很难准确分辨出 60 分和 80 分之间的差距，更无法判断 AI 给出的某个具体结果是高质量的专业输出，还是看起来不错但实际上漏洞百出的低质输出。
例如，你稍微懂一点编程，借助 AI 能写个小程序或简单的网页。但一旦需要写出复杂且稳定的生产级系统，你就难以识别 AI 生成的代码是否存在严重漏洞，哪怕 AI 的输出表面上看起来似乎不错。这时候你做的程序，可能仅仅是看起来好一点的“玩具”，而不是专业标准的软件。
对于真正的专业人士，情况完全不同。他们在使用 AI 时会：
因此，对于“懂一点但不精”的用户群体来说，重要的不是寄希望于 AI 帮你实现“一键专业化”，而是：
正如 @同声翻译樱桃羊 说的：
AI 是给老虎添翼，也让猪能飞上一小会儿，但是并不能让猪变成老虎
专业的能力，就像是你的地图和驾驶技术——只有当你知道自己要去哪里，知道路上可能遇到什么危险，并且遇到紧急情况能手动接管，才能真正驾驭 AI 的力量，安全地驶向你期望的目的地。
AI 时代，并不是降低了对专业的需求，相反，它提升了“专业判断力”的价值。
原文链接：为什么靠 AI“什么都懂一点”，却并不能真正变专业？
2025-04-04 13:13:49
这篇文章探讨了不同年龄段的人在生活和职业中的不同心态。年轻人往往对未来充满憧憬但又感到迷茫，而中年人则通过资源交换来稳固自己的地位，但也可能失去年轻时的激情。文章还提到，毕业后的几年对一个人的职业生涯和气质有着决定性的影响。作者认为，20-24岁是探索世界的年纪，而25-29岁则开始理解社会运作的方式，但可能会失去一些活力。文章最后强调，现实主义的武器（如金钱）对于保护理想主义的理想至关重要。
原文链接：如何守护少年心气
这篇文章讨论了餐饮企业是否应该从单一品类扩展到多品类的问题。文章通过分析椒爱水煮鱼的案例，指出餐饮企业需要根据经营条件和环境变化来决定是否扩展品类。单一品类在客流充足时有优势，但当客流下降时，扩展品类可以吸引更多顾客。此外，文章还提到除了扩品类外，还需要扩大场景和时段以增加收入。最后，文章强调了企业经营的核心是建立、保持和发挥优势，而不仅仅是品牌和认知的问题。
原文链接：餐饮大单品门店的时代谢幕了 两年前，我们开始服务一个专做水 - 即刻App
洛怀
找不到有价值感的理由做一件事，但又觉得这件事确实应该去做，那就找一些没价值感的理由也可以，对理由放宽再放宽，比如我就是闲的没事干，我就是为了装逼，我就是功利，我就是虚荣心作祟，我就是为了让xxx看到，我就是为了向xx证明自己，什么都行，你得有个具体的理由，然后别审判自己的理由，接受它带来的推动。
做任何事都会遇到很多阻碍，有很多人会审判你，你就先别当自己的绊脚石和判官了。
原文链接：找不到有价值感的理由做一件事，但又觉得这件事确实应该去做，那 - 即刻App
职场第一性原理是价值，而不是努力;
成长第一性原理是反思，而不是经历;
投资第一性原理是风控，而不是高回报;
招聘第一性原理是筛选，而不是培养;
管理第一性原理是激发善意，而不是约束员工;
产品第一性原理是击穿痛点，而不是功能叠加;
定位第一性原理是心智占领，而不是聚焦细分;
利润第一性原理是成本效率，而不是高价暴利;
降本第一性原理是消除浪费，而不是减损品质;
创业第一性原理是解决真痛点，而不是满足私欲望;
战略第一性原理是聚焦关键突破，而不是路径规划;
竞争第一性原理是赢得用户，而不是胜过对手;
增长第一性原理是价值空间，而不是流量堆砌;
组织第一性原理是持续进化，而不是架构流程;
营销第一性原理是缩短决策链路，而不是洗脑说服;
广告第一性原理是信号刺激，而不是创意精美;
品牌第一性原理是构建信任，而不是声量轰炸;
创新第一性原理是范式突破，而不是参数进步;
定价第一性原理是心理账户，而不是成本加成;
供应链第一性原理是保证确定性，而不是追求低价;
领导力第一性原理是创造信念感，而不是有人追随;
服务第一性原理是产生依赖，而不是言听计从。
原文链接：第一性原理 mark 一下 职场第一性原理是价值，而不是努 - 即刻App
本文讲述了作者的儿子在户外学校与一个名叫L的孩子发生冲突的故事。起因是L的行为方式非常自我，不遵守规则，导致儿子情绪失控并称呼对方为“dummy”。事后，双方家长及老师进行了沟通，但L的家长拒绝承认孩子存在问题，并认为受到了不公平对待。最终，户外学校决定不接受L入学。此外，文章还提到了春天孩子们采花和儿子学习扬琴的事情。
原文链接：父范学堂 2512 遇上“护犊子”家长
有的人会讨厌你。
有的人讨厌你的理由是合理的。
有的人讨厌你的理由对他们来说是合理的。
有的人会误解你，但是他们意识不到。
有的人了解了你之后反而会讨厌你。
有的人不愿意接受你和ta之间的差异。
有的人看到你时想起了另一个曾经伤害或者让ta反感的人。
有的人只是想找个人讨厌一下。
有的人看着别人讨厌你，也觉得你显得更加可憎。
有的人看着别人喜欢你，于是心生厌恶。
有的人讨厌背后藏着嫉妒和羡慕，或者好奇和爱慕
有的人讨厌你是因为感觉你能承载得住ta的讨厌。
有的人太孤独了，需要找个人来讨厌，来发生一点连结。
有的人不敢讨厌别人，但是在讨厌你这里获得了第一次自由
有的人隔着网络讨厌你，但并不在乎自己讨厌的是谁
有的人会陷在厌恶里出不来，而你刚好出现在ta面前
有的人会因为一些小细节不合心意而讨厌你整个人
有的人一辈子活在厌恶里，所以对他人很难有别的情感
有的人用厌恶掩饰自己的渴望与失望，孤独与向往
有的人只觉得讨厌别人很好玩
有的人讨厌你是因为没有更有趣的事情可以做
总之，这个世界上总有人会讨厌你，但是这些都和你是谁，有多值得被喜欢没有关系。没有人能被所有人喜欢，再美好的人也有可能被讨厌。我们活在这个世界上，为的是早些和喜欢我们的人相逢，去看美景路上的泥泞不值得你注目太久。
原文链接：也许你还没细想过这个问题，但是并不是所有人都会喜欢你。 有 - 即刻App
这篇文章讨论了赚钱的逻辑，指出行动、思维和势（即趋势或运气）是决定人们赚取财富差异的关键因素。在势方面，强调了顺势而为的重要性，并以雷军的成功为例说明跟随社会发展需要的方向更容易成功。思维上，指出了不同地区的人们由于文化背景不同，在工作与创业的选择上有很大差异。最后，文章鼓励读者采取实际行动，即使面对失败也不要畏惧，因为只有开始尝试才能找到新的机会。
原文链接：赚钱的逻辑是什么？什么规律或观念使人与人赚的钱产生了巨大差别？
本文是理想的编辑部与周濂进行的一场对谈。周濂在2012年凭借《你永远都无法叫醒一个装睡的人》一书进入大众视野，此后一直致力于哲学普及工作。此次对话围绕他的新书《打开：周濂的100堂西方哲学课》展开。讨论内容涉及古希腊哲学的重要性、哲学的发展历程以及人工智能时代下的哲学命题。周濂强调了“认识你自己”这一哲学命题在AI时代的紧迫性，并表达了对技术发展可能带来的社会变革的担忧。他还提到当前社会存在偏见固化、后真相等问题，呼吁人们追求共识和真诚的态度。
原文链接：专访｜周濂：狗智时代，孤独的人
广屿Ocean
其实财富自由的真相，并不是赚很多很多钱
最近和一位朋友聊天，她现在30出头几年前从伦敦回国，之后就逐渐让自己转变成了自由职业，现在主要在深圳教小朋友英语，而且打算这么一直持续下去
而这个选择让她的时间相对自由，有很多时间花在自己身上，例如在全世界旅行、练习瑜伽、绘画、更重要的是每天睡到自然醒...我说，你这其实已经实质上实现“财富自由”
为啥?
你想想财富自由的实质是什么，其实就是通过实现经济的绝对独立来换取自己不屈就的独立生活
而我认为她之所以实现了“财富自由”，就是因为“财富自由”不止有赚很多很多钱这一个A方案，她实质上达成了财富自由的B方案:自由职业+稳定的现金流
自由职业＝相对自由的时间和松弛的生活状态，稳定的现金流＝生活的基本保障和心理安全感，你想想看这不就几乎拥有了独立自由的生活了吗？
有人肯定会问，那该怎么保证现金流一直能稳定，技能能不被淘汰一直赚钱？
问的非常好，没有人能保证自己的技能不被淘汰一直赚钱，所以如果在此之上再加一个保险，这个B方案就很完美了，所以完整的财富自由公式是＝自由职业+稳定现金流+利息收益
要有利息收益，就是任何人都不能保证能一直靠自己的技能赚钱，教英语也是，比如未来可能会被AI或某个硬件取代，那么在这能赚钱10年或20年的时间，最好将赚到的钱花在获取稳定的利息收益上
例如10年攒够100万，这100万用于再投资，获取今后稳定的利息收入（比如我从来不碰个股，只投指数，拿利息收入），而不是用来消费享受，要知道花钱也分为消费和购买资产，这是完全不同的两种行为（比如你买车租给别人开就是买资产，但你买车是自己开就是消费）
于是你会发现，赚很多很多钱的“财富自由”A方案只有很少人能实现，而B方案几乎是你只要肯下决心干就有很大几率实现
“笨蛋只盯着财富自由从来没有行动，而智者追求现金流。”
原文链接：其实财富自由的真相，并不是赚很多很多钱 最近和一位朋友聊天 - 即刻App
看到一张很有启发的图片，建议看见这条朋友圈的朋友，把它刻进你的灵魂。
无论你多努力，还是需要让他转化为被别人看到的机会。无论你上班时候多拼，你需要被领导看见。还是你做个人IP，你给客户交付了多少，都应该被看见。
还是你今天多么努力写文章，做短视频，你的过程也应该被看见。
原文链接：看到一张很有启发的图片，建议看见这条朋友圈的朋友，把它刻进你 - 即刻App
杨远骋Koji
昨天这张 twitter 的截图引发了大量的共鸣，全网四处都在传播，今天看到 @Diiiii 的分享：
1）对大多数人来说，与其在供给端追求“最前沿”、“最先进”，不如踏踏实实专注需求端，专注那些“不变的东西”。
2）将 AI 作为改造世界、造福人类、更好满足需求的工具，这样活起来安全感更强一点，幸福感更高一些。
3）与其整天琢磨各种提示词的技巧，不如琢磨一下自己有哪些还没有得到满意答案的问题。
4）对我来说，一个比较有用的练习，是每天想一个“值得用 ChatGPT Pro/O3 来解决” 的问题 - 其实这并不容易。可能未来的挑战很快就会变成，模型不断精进的能力与人类贫乏的想象力之间的矛盾。
5）能否问出“配得上模型能力”的问题？能否对模型的边界提出更大的挑战？这可能是未来对“创新”的真正定义所在。 101 61
原文链接：昨天这张 twitter 的截图引发了大量的共鸣，全网四处都 - 即刻App
这篇文章讨论了中国AI应用市场的现状，特别提到了腾讯、字节跳动和阿里三家公司旗下的AI产品元宝、豆包和夸克的竞争情况。元宝通过砸钱买量及全系入口流量支持来抢占市场；豆包尝试多种功能以促进主动对话；夸克则围绕搜索需求重构AI应用。文章还探讨了AI产品形态的演变，指出“框”与“流”的交互模式之争，并分析了大厂在AI投入上的策略选择。最后，文章强调了AI技术的发展迅速，任何判断的有效期都很短暂。
原文链接：刚和潘乱、张宁录了一期AI应用的播客，其实就是这半年内真正跑 - 即刻App
小野酱大漂亮
前美国作家威廉·德雷塞维奇（WilliamDeresiewicz）在其著作《优秀的绵羊》（ExcellentSheep）中提到了一种奇怪的心理疾病，“斯坦福狂鸭症”（StanfordDuckSyndrome）。“想象一下，一只悠闲的鸭子在湖面上逍遥自在地漂过，水面上的平静掩盖了水面下鸭掌的疯狂拨动。
我甚至觉得我活到目前的人生，都复现这种“狂鸭症”不知道是不是一种悲剧。
原文链接：美国作家威廉·德雷塞维奇（William Deresiewi - 即刻App
2025-03-23 17:37:48
RAG（Retrieval-Augmented Generation）是一种结合了信息检索（Retrieval）和生成（Generation）技术的方法，主要用于提高文本生成的准确性和丰富度。这个方法基于大规模预训练语言模型（LLM），通过在生成文本的过程中，从外部知识库或文档集中检索相关的信息，再将这些信息整合到生成文本中。
RAG的核心组成部分：
工作流程：
Generator本质上是prompt template应用，RAG工程实践更多的关注如何搭建Retriever的pipeline，这边文章主要就是讲讲这块的实践。
经典的搜索系统从文本、图像和上下文中构建简单的表示形式，并建立高效的索引以从中进行搜索。尽管这些系统可以扩展到处理大量内容，但它们通常在处理内容的含义方面存在困难，往往停留在表面层次。
经典搜索和语义搜索的主要区别在于使用向量vector来表示和处理搜索相应的数据，使用embedding（嵌入技术）非常强大，因为它可以用于表示多种类型数据（文本、音频、图片、视频等等），并支持多种类型的查询（有没有发现大模型的多模态其实没有那么神秘）。
先以文本数据相关的RAG为例，我将简单的RAG工程实现架构分为4个pipeline：
文本数据相关的 RAG 会涉及到文本数据的读写，langchain 为了方便开发者处理文本数据抽象一个 Document 对象用于处理所有跟文本数据相关的操作：
在处理LLM相关的数据操作的时候，可以优先考虑使用 langchain 提供的相关封装，目前支持：
示例，加载目录数据：
from langchain_community.document_loaders import DirectoryLoader
text_loader_kwargs = {"autodetect_encoding": True}
loader = DirectoryLoader(
"../", # directory to load
glob="**/*.md", # glob parameter to control which files to load, 'md' means markdown files
show_progress=True, # show a progress bar
use_multithreading=True, # utilize several threads to load files
loader_cls=TextLoader, # customize the loader to specify the loader class
silent_errors=True, # skip the files which could not be loaded and continue the load process
loader_kwargs=text_loader_kwargs # auto detect the file encoding before failing
)
docs = loader.load()
len(docs)
受到 text embedding 模型输入 token 的限制，RAG 检索的时候需要对文本进行分块，以百炼平台的 text embedding 模型为例，text-embedding-v2 模型只支持最多2048 token。
在构建 RAG 系统时，这就带来一个问题 —— 超过2048 token 的文本如何处理？最简单的方式就是进行切分，工程实践上我暂时不做过多的考虑，利用 langchain 提供的 text splitter 对长文本进行分块(How-to guides | 🦜️🔗 LangChain)。
以 markdown header 分块为例：
from langchain_text_splitters import CharacterTextSplitter, MarkdownHeaderTextSplitter
from langchain_community.embeddings.dashscope import DashScopeEmbeddings
from langchain_community.vectorstores import SQLiteVSS
with open("./来自 Google 内部的另外一种声音：AI 没有护城河.md", "r") as f:
md_str = f.read()
# split it into chunks
headers_to_split_on = [("#", "Header 1"), ("##", "Header 2"), ("###", "Header 3")]
markdown_text_splitter = MarkdownHeaderTextSplitter(headers_to_split_on)
md_docs = markdown_text_splitter.split_text(md_str)
md_texts = [md_doc.page_content for md_doc in md_docs]
# create the open-source embedding function
embedding_function = DashScopeEmbeddings(model="text-embedding-v3")
# load it in sqlite-vss in a table named state_union.
# the db_file parameter is the name of the file you want
# as your sqlite database.
db = SQLiteVSS.from_texts(
texts=md_texts,
embedding=embedding_function,
table="state_union",
db_file="./vss.db",
)
# query it
query = "AI的壁垒没有想象中的那么高"
data = db.similarity_search(query)
# print results
data[0].page_content
大文本切分会涉及到上下文丢失的问题，可以参考一片详细解释的文章 Late Chunk in Long-Context Embedding Models，所以在文本分块的时候尝试将所有段落（然后是句子，然后是单词）尽可能长的效果，因为这些段落似乎通常是最强的语义相关文本片段。langchain 通过 recursively split text 来支持这个场景。
from langchain_text_splitters import RecursiveCharacterTextSplitter
# Load example document
with open("./来自 Google 内部的另外一种声音：AI 没有护城河.md") as f:
md_str = f.read()
text_splitter = RecursiveCharacterTextSplitter(
# Set a really small chunk size, just to show.
chunk_size=100,
chunk_overlap=20,
length_function=len,
is_separator_regex=False,
separators=[ # override the list of separators to include additional punctuation
"\n\n",
"\n",
" ",
".",
",",
"\u200b", # Zero-width space
"\uff0c", # Fullwidth comma
"\u3001", # Ideographic comma
"\uff0e", # Fullwidth full stop
"\u3002", # Ideographic full stop
"",
],
)
texts = text_splitter.create_documents([md_str])
print(texts[0])
print(texts[1])
RAG 的文本索引建立完成之后，下一步要做的是如何进行检索，直接进行 search 即可。但是如果我们碰到检索的文本是大文本（超过2k的文本）或者是超大文本（一本红楼梦），工程实践应该怎么处理呢？有两种思路：
from langchain import OpenAI
from langchain.chains.summarize import load_summarize_chain
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain import PromptTemplate
from langchain.chains.summarize import load_summarize_chain
import tiktoken
MODEL_2_ENCODING = {"text-embedding-v1": "cl100k_base", "text-embedding-v2": "cl100k_base", "text-embedding-v3": "cl100k_base"}
MAX_TOKEN = {"text-embedding-v1": 2048, "text-embedding-v2": 2048, "text-embedding-v3":8192}
model_name = "text-embedding-v2"
encoding = tiktoken.get_encoding(MODEL_2_ENCODING[model_name])
# Load example document
with open("./来自 Google 内部的另外一种声音：AI 没有护城河.md") as f:
md_str = f.read()
tokens = encoding.encode(md_str)
print(len(tokens))
text_splitter = RecursiveCharacterTextSplitter(separators=["\n\n", "\n"], chunk_size=10000, chunk_overlap=500)
docs = text_splitter.create_documents([md_str])
map_prompt = """
Write a concise summary of the following:
"{text}"
CONCISE SUMMARY:
"""
map_prompt_template = PromptTemplate(template=map_prompt, input_variables=["text"])
combine_prompt = """
Write a concise summary of the following text delimited by triple backquotes.
Return your response in bullet points which covers the key points of the text.
```{text}```
BULLET POINT SUMMARY:
"""
combine_prompt_template = PromptTemplate(template=combine_prompt, input_variables=["text"])
summary_chain = load_summarize_chain(llm=llm,
chain_type='map_reduce',
map_prompt=map_prompt_template,
combine_prompt=combine_prompt_template,
# verbose=True
)
output = summary_chain.run(docs)
print(output)
# Loaders
from langchain.schema import Document
# Splitters
from langchain.text_splitter import RecursiveCharacterTextSplitter
# Model
from langchain_community.chat_models import ChatTongyi
# Embedding Support
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
# Summarizer we'll use for Map Reduce
from langchain.chains.summarize import load_summarize_chain
# Data Science
import numpy as np
from sklearn.cluster import KMeans
text_splitter = RecursiveCharacterTextSplitter(separators=["\n\n", "\n", "\t"], chunk_size=10000, chunk_overlap=3000)
docs = text_splitter.create_documents([text])
embeddings = DashScopeEmbeddings(model="text-embedding-v2")
vectors = embeddings.embed_documents([x.page_content for x in docs])
# Assuming 'embeddings' is a list or array of 1536-dimensional embeddings
# Choose the number of clusters, this can be adjusted based on the book's content.
# I played around and found ~10 was the best.
# Usually if you have 10 passages from a book you can tell what it's about
num_clusters = 11
# Perform K-means clustering
kmeans = KMeans(n_clusters=num_clusters, random_state=42).fit(vectors)
# Find the closest embeddings to the centroids
# Create an empty list that will hold your closest points
closest_indices = []
# Loop through the number of clusters you have
for i in range(num_clusters):
# Get the list of distances from that particular cluster center
distances = np.linalg.norm(vectors - kmeans.cluster_centers_[i], axis=1)
# Find the list position of the closest one (using argmin to find the smallest distance)
closest_index = np.argmin(distances)
# Append that position to your closest indices list
closest_indices.append(closest_index)
selected_indices = sorted(closest_indices)
llm_model = "qwen-max"
llm = ChatTongyi(temperature=0.8, model=llm_model)
map_prompt = """
You will be given a single passage of a book. This section will be enclosed in triple backticks (```)
Your goal is to give a summary of this section so that a reader will have a full understanding of what happened.
Your response should be at least three paragraphs and fully encompass what was said in the passage.
```{text}```
FULL SUMMARY:
"""
map_prompt_template = PromptTemplate(template=map_prompt, input_variables=["text"])
map_chain = load_summarize_chain(llm=llm,
chain_type="stuff",
prompt=map_prompt_template)
selected_docs = [docs[doc] for doc in selected_indices]
# Make an empty list to hold your summaries
summary_list = []
# Loop through a range of the lenght of your selected docs
for i, doc in enumerate(selected_docs):
# Go get a summary of the chunk
chunk_summary = map_chain.run([doc])
# Append that summary to your list
summary_list.append(chunk_summary)
print (f"Summary #{i} (chunk #{selected_indices[i]}) - Preview: {chunk_summary[:250]} \n")
summaries = "\n".join(summary_list)
# Convert it back to a document
summaries = Document(page_content=summaries)
print (f"Your total summary has {llm.get_num_tokens(summaries.page_content)} tokens")
combine_prompt = """
You will be given a series of summaries from a book. The summaries will be enclosed in triple backticks (```)
Your goal is to give a verbose summary of what happened in the story.
The reader should be able to grasp what happened in the book.
```{text}```
VERBOSE SUMMARY:
"""
combine_prompt_template = PromptTemplate(template=combine_prompt, input_variables=["text"])
reduce_chain = load_summarize_chain(llm=llm,
chain_type="stuff",
prompt=combine_prompt_template,
# verbose=True # Set this to true if you want to see the inner workings
)
output = reduce_chain.run([summaries])
print(output)
The BRV Steps:Load your book into a single text fileSplit your text into large-ish chunksEmbed your chunks to get vectorsCluster the vectors to see which are similar to each other and likely talk about the same parts of the bookPick embeddings that represent the cluster the most (method: closest to each cluster centroid)Summarize the documents that these embeddings represent
这个 pipeline 是利用语义相似性方法来做搜索，主要用来根据文本语义来剔除不相关和冗余的数据，其核心目标是寻找与给定查询最相似的项目。这种搜索方式是基于预先定义好的度量标准来进行的。在那些旨在检索出与用户偏好高度契合的项目的情境下，相似性搜索方法特别有效。我们可以通过多种度量指标来衡量相似性搜索的有效性，例如“cosine similarity”（余弦相似度）、“Jaccard index”（杰卡德指数）以及“Euclidean distance”（欧几里得距离）。这些度量指标有助于确定两个项目之间的关联程度，而准确判断出这种关联程度对于生成精准的推荐是至关重要的。
以 langchain 的 local(也可以设置为 in-memory) vector store 支持的余弦相似度方法来做语义相似性搜索：
from langchain_community.document_loaders import TextLoader
from langchain_community.embeddings.sentence_transformer import (
SentenceTransformerEmbeddings,
)
from langchain_community.embeddings.dashscope import DashScopeEmbeddings
from langchain_community.vectorstores import SQLiteVSS
from langchain_text_splitters import CharacterTextSplitter, MarkdownHeaderTextSplitter
from dotenv import load_dotenv, find_dotenv
# init qwen model config
_ = load_dotenv(find_dotenv("./env/.env"))
# load the document and split it into chunks
loader = TextLoader("./来自 Google 内部的另外一种声音：AI 没有护城河.md")
documents = loader.load()
with open("./来自 Google 内部的另外一种声音：AI 没有护城河.md", "r") as f:
md_str = f.read()
# split it into chunks
headers_to_split_on = [("#", "Header 1"), ("##", "Header 2"), ("###", "Header 3")]
markdown_text_splitter = MarkdownHeaderTextSplitter(headers_to_split_on)
md_docs = markdown_text_splitter.split_text(md_str)
md_texts = [md_doc.page_content for md_doc in md_docs]
# create the open-source embedding function
# embedding_function = SentenceTransformerEmbeddings(model_name="all-MiniLM-L6-v2")
embedding_function = DashScopeEmbeddings(model="text-embedding-v2")
# load it in sqlite-vss in a table named state_union.
# the db_file parameter is the name of the file you want
# as your sqlite database.
db = SQLiteVSS.from_texts(
texts=md_texts,
embedding=embedding_function,
table="state_union",
db_file="./vss.db",
)
# query it
query = "AI的壁垒没有想象中的那么高"
data = db.similarity_search(query)
# print results
data[0].page_content
MMR（最大边际相关性）是为了在推荐中平衡相关性和多样性而设计的。它旨在选择不仅与用户的查询相关，而且足够多样化的项目，以避免重复。这在用户可能收到多个过于相似的推荐的场景中尤其重要，因为这会导致体验不够吸引人。
为什么需要 MMR，举个简单的例子来进行说明和理解：假设用余弦相似度进行相似性搜索的时候，top_k 设置为4即搜索结果中包含四个结果。此时会出现一种情况，一个与 query 相似性非常高的大文本，在做 text chunk 的时候，本分成了5个 data chunk，此时搜索结果只会是这个大文本，因为它占据了4个位置，其他相似的文本无法进入 top_k。MMR进行搜索就是来平衡相关性和多样性得到最终的排名的。
以一个简单 retriver 检索为例，观察一下 MMR 搜索结果有什么差异：
# retriever with MMR
from langchain_community.vectorstores import InMemoryVectorStore
from langchain_community.embeddings.dashscope import DashScopeEmbeddings
from langchain_core.documents import Document
from dotenv import load_dotenv, find_dotenv
# init qwen model config
_ = load_dotenv(find_dotenv("./env/.env"))
embeddings = DashScopeEmbeddings(model="text-embedding-v3")
vectorStore = InMemoryVectorStore(embeddings)
document1 = Document(page_content="The powerhouse of the cell is the mitochondria", metadata={ "source": "https://example.com" })
document2 = Document(page_content="Buildings are made out of brick", metadata={ "source": "https://example.com" })
document3 = Document(page_content="Mitochondria are made out of lipids", metadata={ "source": "https://example.com" })
documents = [document1, document2, document3]
vectorStore.add_documents(documents)
simi_ret = vectorStore.similarity_search("biology", k=2)
print(simi_ret)
mmr_ret = vectorStore.as_retriever(search_type="mmr", search_kwargs={"k": 2, "lambda_mult": 0.5}).invoke("biology")
print(mmr_ret)
################
# output print #
################
[Document(id='cd06846b-aab4-4417-bfac-204838fb3bc1', metadata={'source': 'https://example.com'}, page_content='The powerhouse of the cell is the mitochondria'), Document(id='d6e7bb82-9b9f-4ff7-8404-96e24300295b', metadata={'source': 'https://example.com'}, page_content='Mitochondria are made out of lipids')]
[Document(id='cd06846b-aab4-4417-bfac-204838fb3bc1', metadata={'source': 'https://example.com'}, page_content='The powerhouse of the cell is the mitochondria'), Document(id='9226e3c3-7c81-4f08-9909-3ba4e066c9db', metadata={'source': 'https://example.com'}, page_content='Buildings are made out of brick')]
结合 step1 和 step2 检索到的相关文本之后，需要根据具体的问题利用 LLM 的文本生成能力进行问答即针对特定场景的 prompt 模版进行LLM generation，如下是一个简单的例子：
prompt_template = """Use the following pieces of context to answer the question at the end.
If you don't know the answer, just say that you don't know, don't try to make up an answer.
{context}
Question: {question}
Answer:"""
PROMPT = PromptTemplate(
template=prompt_template, input_variables=["context", "question"]
)
llm.predict(text=PROMPT.format_prompt(
context=compressed_docs,
question=question
).text)
self-query retrieve 顾名思义具有查询自身的能力。具体来说，给定任何自然语言查询，self-query retriever 使用 query 构建 LLM 链来编写结构化查询，然后将该结构化查询应用于其底层向量存储。这使得检索器不仅可以使用用户输入的查询与存储文档的内容进行语义相似性比较，还可以从用户查询中提取存储文档元数据的过滤条件并执行这些过滤条件。
一下是以 DashVector 向量检索服务为例的样例代码：
from langchain_core.documents import Document
from langchain_community.vectorstores import InMemoryVectorStore
from langchain_community.vectorstores import DashVector
from langchain_community.embeddings.dashscope import DashScopeEmbeddings
from langchain.chains.query_constructor.schema import AttributeInfo
from langchain.retrievers.self_query.base import SelfQueryRetriever
from langchain_community.chat_models import ChatTongyi
from dotenv import load_dotenv, find_dotenv
# init qwen model config
_ = load_dotenv(find_dotenv("./env/.env"))
docs = [
Document(
page_content="A bunch of scientists bring back dinosaurs and mayhem breaks loose",
metadata={"year": 1993, "rating": 7.7, "genre": "science fiction"},
),
Document(
page_content="Leo DiCaprio gets lost in a dream within a dream within a dream within a ...",
metadata={"year": 2010, "director": "Christopher Nolan", "rating": 8.2},
),
Document(
page_content="A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea",
metadata={"year": 2006, "director": "Satoshi Kon", "rating": 8.6},
),
Document(
page_content="A bunch of normal-sized women are supremely wholesome and some men pine after them",
metadata={"year": 2019, "director": "Greta Gerwig", "rating": 8.3},
),
Document(
page_content="Toys come alive and have a blast doing so",
metadata={"year": 1995, "genre": "animated"},
),
Document(
page_content="Three men walk into the Zone, three men walk out of the Zone",
metadata={
"year": 1979,
"director": "Andrei Tarkovsky",
"genre": "thriller",
"rating": 9.9,
},
),
]
embeddings = DashScopeEmbeddings(model="text-embedding-v3")
# in-memory vector store
vector_store = InMemoryVectorStore(embeddings)
vector_store.add_documents(documents)
# sqlite vector store with local storage
vector_store = SQLiteVSS.from_documents(
documents,
embeddings,
table="movies",
db_file="./vss-self-query.db",
)
# dashscope vector store service
vector_store = DashVector.from_documents(docs, embeddings)
metadata_field_info = [
AttributeInfo(
name="genre",
description="The genre of the movie. One of ['science fiction', 'comedy', 'drama', 'thriller', 'romance', 'action', 'animated']",
type="string",
),
AttributeInfo(
name="year",
description="The year the movie was released",
type="integer",
),
AttributeInfo(
name="director",
description="The name of the movie director",
type="string",
),
AttributeInfo(
name="rating", description="A 1-10 rating for the movie", type="float"
),
]
document_content_description = "Brief summary of a movie"
llm_model = "qwen-max"
llm = ChatTongyi(temperature=0.8, model=llm_model)
retriever = SelfQueryRetriever.from_llm(
llm,
vector_store,
document_content_description,
metadata_field_info,
)
# This example only specifies a filter
retriever.invoke("I want to watch a movie rated higher than 8.5")
# This example specifies a query and a filter
retriever.invoke("Has Greta Gerwig directed any movies about women")
# This example specifies a composite filter
retriever.invoke("What's a highly rated (above 8.5) science fiction film?")
# This example specifies a query and composite filter
retriever.invoke(
"What's a movie after 1990 but before 2005 that's all about toys, and preferably is animated"
)
P.S. 研究一下 self-query 背后的原理：
# self-query from scratch
from langchain.chains.query_constructor.base import (
StructuredQueryOutputParser,
get_query_constructor_prompt,
)
from langchain.chains.query_constructor.schema import AttributeInfo
from langchain_community.chat_models import ChatTongyi
from dotenv import load_dotenv, find_dotenv
# init qwen model config
_ = load_dotenv(find_dotenv("./env/.env"))
document_content_description = "Brief summary of a movie"
metadata_field_info = [
AttributeInfo(
name="genre",
description="The genre of the movie. One of ['science fiction', 'comedy', 'drama', 'thriller', 'romance', 'action', 'animated']",
type="string",
),
AttributeInfo(
name="year",
description="The year the movie was released",
type="integer",
),
AttributeInfo(
name="director",
description="The name of the movie director",
type="string",
),
AttributeInfo(
name="rating", description="A 1-10 rating for the movie", type="float"
),
]
llm_model = "qwen-max"
llm = ChatTongyi(temperature=0.8, model=llm_model)
prompt = get_query_constructor_prompt(
document_content_description,
metadata_field_info,
)
output_parser = StructuredQueryOutputParser.from_components()
query_constructor = prompt | llm | output_parser
print(prompt.format(query="dummy question"))
query_constructor.invoke(
{
"query": "What are some sci-fi movies from the 90's directed by Luc Besson about taxi drivers"
}
)
输出结果：
Your goal is to structure the user's query to match the request schema provided below.
<< Structured Request Schema >>
When responding use a markdown code snippet with a JSON object formatted in the following schema:
```json
{
"query": string \ text string to compare to document contents
"filter": string \ logical condition statement for filtering documents
}
```
The query string should contain only text that is expected to match the contents of documents. Any conditions in the filter should not be mentioned in the query as well.
A logical condition statement is composed of one or more comparison and logical operation statements.
A comparison statement takes the form: `comp(attr, val)`:
- `comp` (eq | ne | gt | gte | lt | lte | contain | like | in | nin): comparator
- `attr` (string): name of attribute to apply the comparison to
- `val` (string): is the comparison value
A logical operation statement takes the form `op(statement1, statement2, ...)`:
- `op` (and | or | not): logical operator
- `statement1`, `statement2`, ... (comparison statements or logical operation statements): one or more statements to apply the operation to
Make sure that you only use the comparators and logical operators listed above and no others.
Make sure that filters only refer to attributes that exist in the data source.
Make sure that filters only use the attributed names with its function names if there are functions applied on them.
Make sure that filters only use format `YYYY-MM-DD` when handling date data typed values.
Make sure that filters take into account the descriptions of attributes and only make comparisons that are feasible given the type of data being stored.
Make sure that filters are only used as needed. If there are no filters that should be applied return "NO_FILTER" for the filter value.
<< Example 1. >>
Data Source:
```json
{
"content": "Lyrics of a song",
"attributes": {
"artist": {
"type": "string",
"description": "Name of the song artist"
},
"length": {
"type": "integer",
"description": "Length of the song in seconds"
},
"genre": {
"type": "string",
"description": "The song genre, one of "pop", "rock" or "rap""
}
}
}
```
User Query:
What are songs by Taylor Swift or Katy Perry about teenage romance under 3 minutes long in the dance pop genre
Structured Request:
```json
{
"query": "teenager love",
"filter": "and(or(eq(\"artist\", \"Taylor Swift\"), eq(\"artist\", \"Katy Perry\")), lt(\"length\", 180), eq(\"genre\", \"pop\"))"
}
```
<< Example 2. >>
Data Source:
```json
{
"content": "Lyrics of a song",
"attributes": {
"artist": {
"type": "string",
"description": "Name of the song artist"
},
"length": {
"type": "integer",
"description": "Length of the song in seconds"
},
"genre": {
"type": "string",
"description": "The song genre, one of "pop", "rock" or "rap""
}
}
}
```
User Query:
What are songs that were not published on Spotify
Structured Request:
```json
{
"query": "",
"filter": "NO_FILTER"
}
```
<< Example 3. >>
Data Source:
```json
{
"content": "Brief summary of a movie",
"attributes": {
"genre": {
"description": "The genre of the movie. One of ['science fiction', 'comedy', 'drama', 'thriller', 'romance', 'action', 'animated']",
"type": "string"
},
"year": {
"description": "The year the movie was released",
"type": "integer"
},
"director": {
"description": "The name of the movie director",
"type": "string"
},
"rating": {
"description": "A 1-10 rating for the movie",
"type": "float"
}
}
}
```
User Query:
dummy question
Structured Request:
StructuredQuery(query='taxi drivers', filter=Operation(operator=<Operator.AND: 'and'>, arguments=[Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='genre', value='science fiction'), Comparison(comparator=<Comparator.GTE: 'gte'>, attribute='year', value=1990), Comparison(comparator=<Comparator.LTE: 'lte'>, attribute='year', value=1999), Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='director', value='Luc Besson')]), limit=None)
AI Agent v.s. Agentic AI
在AI领域中，AI Agent（智能体）与Agentic AI（能动AI）虽密切相关却各有侧重。AI Agent是具体的智能实体，能在特定环境中感知、决策并执行动作以完成任务，通常基于机器学习和人工智能技术，具备一定的自主性和自适应性，主要关注单一功能或任务，如AI客服系统。而Agentic AI是一个更广泛的术语，强调AI系统在更高层面上的自主决策和问题解决能力，不仅能够感知和执行任务，还能主动思考、规划和适应环境的变化，涵盖设计和改进AI Agent的方法和框架，探索其更广泛和通用的潜力，目标是实现更广泛、更复杂的任务，能够在动态环境中自主地进行学习和优化，应用范围更广，可在不同领域和场景发挥作用，智能程度更高，不仅能处理数据、决策，还能从互动中学习并优化自身行为，使用更复杂的算法，如强化学习、元学习、大模型结合自监督学习，适用于复杂系统，如自动驾驶系统、智能金融分析、火星探测机器人等，由于其高度自主性和广泛的应用范围，伦理和风险问题更为复杂，需要更多的关注和研究。
传统的 RAG 系统受到静态工作流程的限制，缺乏多步骤推理和复杂任务管理所需的适应性。Agentic Retrieval-Augmented Generation（Agentic RAG）通过将自主人工智能代理嵌入 RAG 管道，超越了这些限制。
Agentic RAG 将 ReACT 的推理能力与 Agent 的任务执行能力相结合，创建一个动态和自适应的系统。与遵循固定管道的传统 RAG 不同，Agentic RAG 通过使用 ReACT 根据用户查询的上下文动态协调 Agent，引入了灵活性。这使得系统不仅能够检索和生成信息，还能够根据上下文、不断变化的目标和与之互动的数据采取明智的行动。这些进步使 Agentic RAG 成为一个更强大和灵活的框架。模型不再仅限于被动响应用户查询；相反，它可以主动规划、执行并调整其方法以独立解决问题。这使得系统能够处理更复杂的任务，动态适应新挑战，并提供更具上下文相关性的响应。
以搜索 Wikipedia 为例，这个 zero-shot-agent 就是 Agentic RAG 的雏形：
from langchain import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.agents import initialize_agent, Tool
from langchain.utilities import WikipediaAPIWrapper
from langchain_community.chat_models import ChatTongyi
wikipedia = WikipediaAPIWrapper()
llm_model = "qwen-max"
llm = ChatTongyi(temperature=0.8, model=llm_model)
tools = [
Tool(
name="Wikipedia",
func=wikipedia.run,
description="Useful for when you need to get information from wikipedia about a single topic"
),
]
agent_executor = initialize_agent(tools, llm, agent='zero-shot-react-description', verbose=True)
output = agent_executor.run("Can you please provide a quick summary of Napoleon Bonaparte? \
Then do a separate search and tell me what the commonalities are with Serena Williams")
print(output)
2025-03-22 21:20:27
该页面讨论了关于使用机器人军队的法律和道德问题。随着技术的进步，自主武器系统的出现引发了对于战争法则、责任归属以及人工智能决策透明度等方面的担忧。
原文链接：hyponymous :: 100% Unemployment
在过去12个月里，作者发现自己不再害怕项目过大、过于复杂，或者担心项目使用自己不熟悉的编程语言或技术。以前由于需要大量研究和技术挑战而放弃的项目，现在借助于更好的工具和AI的帮助变得容易得多。例如，他重新尝试了一个14年前的填充水平传感器项目，在短短两小时内就完成了原来需要六周时间的工作。这使他意识到，有了当前的技术支持，许多以前看似不可能完成的任务现在都变得可行了。他感到兴奋，并开始重新考虑那些曾经认为太复杂或超出能力范围的业余项目。
原文链接：With AI You Need to Think Much Bigger! |
洛怀
和k聊天，聊到为什么现在人好像没完没了地追求“成长”，这是不是一种病。但我想了想，其实很多时候也不是人主观上要成长，而是你只要做事，持续做事，就一定会遭到社会的毒打，你被打了你悟了你就会成长。一个人如果不成长，只有可能是他没在做事，或者没做什么新的事。
成长只是做事的副产品，谈不上追求不追求的，刻意追求的成长也都是纸上谈兵空中楼阁，就像早上5点起床的自律vlog一样毫无意义。真正的成长根本不需要你去追求，它拿着大棒子就直接来追你了，你躲都躲不及。
原文链接：和k聊天，聊到为什么现在人好像没完没了地追求“成长”，这是不 - 即刻App
这篇文章讨论了“vibe coding”这一新现象，这是一种依赖AI辅助编程的方式。它由Andrej Karpathy提出，描述了一种模糊的编程实践：程序员不再严格审查代码差异，而是接受AI的建议，并通过不断试错来解决错误。虽然这种方法可以提高效率，但也导致代码难以理解，问题层出不穷。文章指出，vibe coding反映了当前时代的一种不确定性，人们逐渐接受了这种变动不居的状态。
原文链接：如果你是程序员但还没听说过 vibe coding，那你已经 - 即刻App
hi，我是 Ray。
不知道你没有发现，那些你身边 AI 用得好的人，他们本身的学习能力，就会高出一截。
当然，学习能力强的人，什么都学得比别人快，但 AI 会持续放大这个差距：
原本比你学习效率快 1 倍的人，现在有了 AI，可能会快 10 倍。
AI 不会让所有了都变强，普通人只能被加速普通。
这也是为什么我一直强调，思维能力会变得前所未有的重要，
为什么？
因为 AI 不是智慧的来源，它只是你的思维映射。
从信息论的角度看，AI 本质上是一个“信息压缩系统”，它决定不了你的上限，只能保障你的下限。
让 AI 写篇文章，大多数人就直接一句话：
请你给我写一篇 xxx 主题的爆款文章。
这就像领导给我布置任务，只有一句话的命令，我不知道它的目标，不知道这件事的背景，况且领导不说，咱也不好问，那我只能自己的理解去写这篇文章...
那最后的效果自然不好，因为这里面的「信息差」太多。
稍微会一点的人，懂得给出背景与目标，这样 AI 知道前因后果，至少能给出一个大方向一致的内容。
那如果再好一点呢？
那就是教会它，到底什么才是最好的，甚至怎么做才是最好的。
丢给它几篇自己觉得还行的文章，叫 AI 来仿写；
或者自己总结一套效果最好的框架，让 AI 直接照做。
但是，这里面有一个核心的问题：什么叫做好？
你找了几篇同赛道博主的文章，人家粉丝量比你大，服化道比你好，镜头风格和你完全不一样，那他的爆款真的适合你？
你总结了一套效果最好的框架，但实际上，你自己都没写过爆文，那你让 AI 照着做有什么意义？
你不过是在努力地让 AI 放大你的错误。
而这还只是一个业务场景的使用，要想真的让 AI 提高内容创作效率，可能需要涉及公众号、小红书、朋友圈等多个场景...
所以，别急着学 AI，你更应该学的，是如何思考。
分享一下我们自己内部的 AI 智能体是怎么去做的，也是多亏了它，才有了之前 40 天涨粉 2 万的结果。
第一个阶段，我们也不知道什么叫好的公众号，
那怎么办？
先去找「业务专家」学。
谁公众号做得好，就先去找别人学，付费的、免费的，无论什么方式，只要能搞到别人的写作逻辑，我们都会去尝试。
于是，一两周下来，我们对于「什么叫好的公众号文章」，有了一定的理解。
然后，到了第二个阶段。
通常意义上的「好」，其实不一定适合自己。
所以，要结合自己的需求，做更多的个性化定制。
那这个时候，需要什么能力？
就是你自己对业务的思考能力。
第一步借用了业务专家的提示词，输出之后，哪里好？哪里不好？问题在哪？如何优化提示词？如何优化业务流？
这些答案，都需要靠你自己去找到。
我们大部分人对 AI 的认知，实际上完全没有任何逻辑，所以我们焦虑，我们怕被 AI 取代...
理解 AI，最重要的是培养思考能力，培养工具思维。
在思维不成熟的阶段，AI 只会加速你的幻觉产生：
以为自己学会了，但其实只复制了表面技巧。
人与人的竞争，真正的壁垒从来不是工具本身，而是：
如果你不会思考，那 AI 只会让你变成一个高效的平庸者。
普通人用计算器算账，数学家用计算器推导新的科学定律，而华尔街交易员，他们用计算器赚到了普通人一辈子赚不到的钱。
AI 也是如此。不要再焦虑于每天都有哪些 AI 新工具，都有哪些 AI 技术更新，门槛低的，人人都能有的，那必然不会成为你的核心壁垒。
那以终为始来看，现在也没必要去花时间研究。
AI 让所有人都能生产内容，但真正能创造影响力的，还是那些对一件事，思考最深、理解最透的人。
原文链接：【人人都能用上的东西，那肯定就不能叫壁垒。】 hi，我是 - 即刻App
马丁的面包屑
跳槽原来的用法是是妓女换恩客的指代
原文来自徐珂《清稗类钞》——原指妓女而言，谓其琵琶别抱也，譬以马之就饮食，移就别槽耳。后则以言狎客，谓其去此适彼。
花魁们都知道
努力打工是为了有一天赎身
而不是一辈子给青楼当头牌
原文链接：跳槽原来的用法是是妓女换恩客的指代 原文来自徐珂《清稗类钞 - 即刻App
快乐拽姐小刘
杭州吃喝玩乐电台 主播小刘🌷
以下是杭州春天可以免费做的一些事情：
轻松享受杭州春天的美好。
原文链接：杭州吃喝玩乐电台 主播小刘🌷 以下是杭州春天可以免费做的一 - 即刻App
本文探讨了AI技术在职场中的应用引发的焦虑和适应问题。许多公司要求员工学习并使用AI工具，如DeepSeek，并将其纳入考核标准，导致员工感到压力和焦虑。一些人担心自己的职业价值被取代，而另一些人则努力适应并寻找与AI共存的方式。通过摸索和学习，一些从业者逐渐找到了利用AI提高工作效率的方法，但同时也意识到AI目前还无法完全替代人类的创造力和情感表达。最终，人们认识到应理性看待AI，既不轻视也不高看，将其作为辅助工具，专注于更具深度和创造性的工作。
原文链接：AI写进KPI，“逼疯”打工人
文章探讨软件开发领域存在的炒作现象与真实技术变革。通过tj-actions被黑案例强调专业技能不可替代性，同时以作者使用Cursor工具快速开发项目的亲身经历，指出AI辅助工具带来的效率提升是值得关注的实质性进步，印证了部分技术变革的真实性。
💜 Flow over friction – Ride the wave, don't fight it.
💜 Iteration over perfection – Perfection is obsolete if you can always reroll.
💜 Augmentation over automation – AI is a collaborator, not a replacement.
💜 Product thinking over code crafting – What matters is what you build, not how you write it.
💜 Rerolling over debugging – If fixing takes too long, regenerate.
💜 Human taste over technical constraints – The best tech serves great taste, not the other way around.
That is, while there is value in the items on the right, we value the items on the left more.
Discover divine wisdom and guidance through our free random Bible verse generator. Each verse offers unique inspiration for your daily spiritual journey.
“He who lets the goat go as the scapegoat shall wash his clothes, and bathe his flesh in water, and afterward he shall come into the camp.
— Leviticus 16:26(World English Bible)
原文链接：Random Bible Verse Generator | Bible Quotes
你是否经常观察身边的朋友，发现那些快速成长的人都有一个明确清晰的发展方向？其实就是“人生算法”。
那么，什么是人生算法？它又如何影响我们的人生呢？
接下来，让我们一起探索这四种迹象，找到属于自己的成长密码。
不安分的人总是习惯性地反思：我对现在的工作和生活满意吗？我能不能做到更好？
建议：
1）定期思考：每3~6个月思考一次，现在的生活是我想要的吗？我还能做到更好吗？
2）别怕改变：如果当下的生活不是你想要的，那就勇敢改变。
3）不怕选择：选择是相对的,还要相信懂的人
4）做好手头事，努力赚钱：赚钱能治愈一切矫情。定期思考
做好手头事努力赚钱
现代人对碎片时间的利用已经到了令人发指的地步。罗振宇提出“国民总时间”的概念，指出未来用户的个人时间将成为商业的终极战场。
建议：
1）远离杀时间的产品：如头条、抖音、快手等。
2）科学规划时间：工作日全力以赴工作、学习、运动，周末尽情玩。
3）学会拒绝：把80%的精力投注到真正重要的事情上。
4）学会科学休息：良好的休息是一切生活和工作的基础。
麦肯锡的工作准则：如果对你的要求是100，即使你达到了100但没有远远超出100，虽然没人说你什么，但你就是不合格。
建议：
1）永远思考：怎么才能做得更好？
2）不要降低要求：有了第一次，就一定会有第二次、第三次。
3）提出切合实际的目标：从相对容易的角度切入，有可执行、可落实到细节的计划。
禅宗讲的初学者心态，也就是空杯心态。对待新的知识、思想不要有任何成见，也不要因为情绪、经验拒绝新的知识和思想。
建议：
1）批判别人之前，想想是不是因为自己太low看不到别人的牛逼之处。
2）遇到新知识和思想前，不要急于否定，先了解，再思考，最后做结论。
3）建立自己的常规信息来源：定期查看行业论文、行业网站、科技网站等。
原文链接：人生算法：一个人开始快速成长的4种迹象
本文通过日本、英国、中东等多国王室成员案例，揭示精英教育体系下继承人普遍存在的学术造假、心理问题与能力缺陷。文章指出精英教育过度追求名校标签与社会地位，导致学生丧失自我发展空间，并探讨当代社会逐渐从盲目崇拜精英教育转向重视个体幸福与自由价值的观念转变。
原文链接：精英教育，正在量产“废掉的二代”
本文通过ClockQA与CalendarQA数据集测试发现，多模态大模型在时间理解上存在显著缺陷。七款主流模型（包括GPT-4o、Gemini 2.0等）在钟表识别任务中最高准确率仅22.58%，日历任务中GPT-o1表现最佳达80%。研究揭示AI在指针角度识别、罗马数字解析、日期推算等基础时间认知环节存在视觉识别与逻辑推理的双重短板，暴露出当前多模态模型的'时间盲区'。
原文链接：研究发现，大模型不懂时间
文章分析了DeepSeek AI的写作风格：偏好量子力学等科学概念、滥用生僻词、依赖精确数字、格式化意象堆砌，指出其缺乏人类作者独特的个性化表达。作者认为AI本质是数据缝合体，而人类写作的核心价值在于不可复制的自我意识。
原文链接：暂时不敢用deepseek写作了
Ryan.eth
所有人都想改变世界，但没有人愿意洗碗
原文链接：所有人都想改变世界，但没有人愿意洗碗 - 即刻App
木遥
AI 写的东西不够好看的本质原因可能是 AI 不痛苦
原文链接：AI 写的东西不够好看的本质原因可能是 AI 不痛苦 - 即刻App
洛怀
和k聊天，聊到为什么现在人好像没完没了地追求“成长”，这是不是一种病。但我想了想，其实很多时候也不是人主观上要成长，而是你只要做事，持续做事，就一定会遭到社会的毒打，你被打了你悟了你就会成长。一个人如果不成长，只有可能是他没在做事，或者没做什么新的事。
成长只是做事的副产品，谈不上追求不追求的，刻意追求的成长也都是纸上谈兵空中楼阁，就像早上5点起床的自律vlog一样毫无意义。真正的成长根本不需要你去追求，它拿着大棒子就直接来追你了，你躲都躲不及。
原文链接：和k聊天，聊到为什么现在人好像没完没了地追求“成长”，这是不 - 即刻App
julian.
真的做一款产品最大的痛苦是：
most people just dont care.
当你把所有注意力放在要做的产品上的时候，你会去优化一些很深入的细节，想一些听上去很巧妙的逻辑。但其实 most people just dont care。他们不仅不 care 你的细节，他们也不 care 你的产品，他们也不 care 你。
他们 care 的是自己的生活往复和遥远的新闻热点，thats all，无情又真实。不过日常生活中你对他人的新东西往往也是这样的。
这才是关于创造之后的第一课。
原文链接：真的做一款产品最大的痛苦是： most people jus - 即刻App
李继刚
我不喜欢「吵架」。
从「心」的角度看，是因为内心深处害怕冲突，我在躲它。
从「脑」的角度看，每个人脑海中都已经完成了自洽闭环（否则他何以立世）。大部分人是没有意识⇒意愿去打破自己的自洽的，这太他妈痛苦了。
吵架，就是两个自洽闭环的不相容，各说各话，一通表达，打完收功，完成新一轮的巩固强化。
这个世界，容得下不同。我挺喜欢看多样性的。
如果大家都一样，想想也挺无趣的。
原文链接：我不喜欢「吵架」。 从「心」的角度看，是因为内心深处害怕冲 - 即刻App
这是一个让你连接到20年前互联网的“浏览器”
原文链接：上网2005
洛怀
社交的时候，当你把话像球一样抛出去，就不要再去想对方怎么接，会不会接，这是对方该想的事情。要耐受抛出球和对方接住球中间的那段空白。即使对方最后没有接球，让球掉在了地上，那也不是你抛球的问题。
原文链接：社交的时候，当你把话像球一样抛出去，就不要再去想对方怎么接， - 即刻App
文章报道了网络大V司马南因偷税漏税被税务部门查处的情况。2019年至2023年间，司马南通过隐匿收入、虚假申报等手段少缴税费共计537.75万元。北京市税务局稽查局对其追缴税费款、加收滞纳金及罚款共计926.94万元。文章指出，司马南长期以来在网上以“反美斗士”形象攻击民营企业家，并标榜自己为“正义斗士”。此次查处表明在中国守法经营应受到保护，而违法行为无论其光环如何都应受到严惩。
原文链接：风声丨司马南偷税被查，有标志意义
本文讨论了AI智能体的发展遵循类似于摩尔定律的趋势，即随着时间的推移，AI智能体的能力大约每两年翻一番。这种增长主要得益于算法的进步、数据量的增加以及计算能力的提升。
原文链接：Nature发文「智能体摩尔定律」，Agent能力每7个月翻倍 | 量子位
2025-03-17 12:30:42
至少有两种时间交换模式：「线性交换」和「复利交换」
前者，无论你多么聪明、多么高效、多么专业，只要你的价值创造依然与你的「在场」紧密绑定，你就仍然被困在一个严格的价值上限之内。即使笼子镀了金，那仍然是笼子。
后者，是一种你不必亲自在场，价值仍能持续产生的关系，是任何能将你的智力、创造力与时间解耦的方式。
这不仅是一个经济问题，更是一个存在问题。当我们将有限的生命转化为可以脱离在场而持续产生价值时，在某种程度上实现了对死亡的超越。我们的思想、创造和影响可以在我们离开后继续存在，继续创造价值。
热门评论
第一种是时间换钱，比如出租车司机、快递员、职场程序员、职场管理者、餐厅服务员等。
第二种是资产生钱，比如土地公、投资人、有 IP 的内容创作者、有用户持续付费的产品人等。
或许 AI 最大的价值，是让越来越多的人，可以从以时间换钱的生存模式，进化到开始创造属于自己的资产，以资产生钱的模式来生存。
原文链接：至少有两种时间交换模式：「线性交换」和「复利交换」
再给“行业共识”破盆冷水：我不认可 agent 这个方向，反而 copilot 的 in-context 交互是更重要的。
无论是 ai 还是其他任何科技，我们的分析首先应回归真实的生活。不作用于人们生活而只体现在文章和估值里的科技，可能不是我想要的。当然总有人为了自身利益无视其他人的生活，还嘲笑其他人看不懂；我对此保持沉默。
原文链接：再给“行业共识”破盆冷水：我不认可 agent 这个方向，反 - 即刻App
目前看，ai非常大的一个威胁是，提供给人类一种“思考幻觉”，在前ai时代，普通人和各领域精英间的一个普遍差异，是有没有结构化思考/结构化输出的能力
从r1和manus来看，ai应用最强的地方之一就是结构化能力——去拆解问题和任务，它拆完了之后，把这个结构化的过程展示出来，就给了用户一个我也能结构化的错觉
这对于已经有类似能力的老炮来说，没啥问题，省时间多好，但对于在成长期的学生和职场幼崽来说，如果完全用ai来替代结构化思考的部分，完全不去做从0到1的事情，会丧失掉这个学习提高的过程中附带的收益，也会潜在失去向更高阶思维能力（创造力-直觉-分析复杂问题）的攀登可能
就算从最基本的角度来看，也会至少丧失掉积累一些底层思维素材的机会，而且长期来看可能会让思维活性下降，表面上看，一些任务仍然可以完成，甚至通过ai展示的“思考过程”，认为自己仍然有做这些事的能力，但其实已经根本没法自己上手去做基础性的思考了，我觉得这可能是摆在这一代全球教育者和父母面前的一个特别大的挑战
热门评论
善存维生素片: 但以后AI门槛进一步降低，一堆垂直打包好的AI工具，到时候可能都不需要提问太多了，连提问能力都训练不了。
每天前行30公里: 是的。AI的发展趋势是这样的。
原文链接：目前看，ai非常大的一个威胁是，提供给人类一种“思考幻觉” - 即刻App
本文探讨了近年来AI模型性能提升的原因，主要集中在后训练阶段。通过将这一过程与F1赛车进行类比，说明了即使基础模型变化不大，通过后训练也可以实现显著的性能提升。文章详细介绍了“激发理论”（elicitation theory），认为后训练主要是从基础模型中提取和放大有价值的行为。此外，文章还反驳了表面一致假设（Superficial Alignment Hypothesis），指出后训练不仅仅是对模型风格的微调，而是能够教授模型新的技能。最后，文章强调了强化学习（RL）在后训练中的作用，并指出强大的基础模型是后训练成功的关键。
原文链接：Elicitation, the simplest way to understand post-training
玉伯
最近好多人问我如何评价 Manus
我会尝试反向问对方是什么感受
得到一个很有意思的观察是
大厂人往往会把其归结为过度营销
投资人则关注壁垒是什么、商业模式是啥
创业者大多会兴奋、看到了机会
普通用户会迷茫：这是啥
媒体人更直接：有没有码
细思这背后，都是在看自己
大厂人担心丢了尊严，用营销解释容易心安
投资人是 FOMO，担心没投错过、投了亏钱
创业者是羡慕，希望下一个是自己
用户最朴实：这是啥，是最客观的评价者
媒体人，是在想着，怎么获取截图和流量
忙忙碌碌，皆是围绕自己
只有用户，保持着朴素的好奇心：这是啥
原文链接：最近好多人问我如何评价 Manus 我会尝试反向问对方是什么 - 即刻App
和老板1v1要聊些啥？
我有个习惯是和团队的核心成员每2周1v1沟通半小时，了解下他们的工作状态，回答实际工作和职场发展的问题。我发现很多同学其实不太会利用和老板1v1的机会，往往只是做简单的工作汇报。
站在员工角度，其实有效地用好和老板1v1的机会，能够收获很多职场的经验和见识，运气好还能提升升职加薪的机率。分享几个和老板高效1v1的小技巧给大家。
1）合理选择时间地点
和老板1v1的目的不是再做一次工作汇报，而是在休闲轻松的环境下，让彼此敞开心扉沟通，增加了解，互相帮助提升未来的工作效率。因此，1v1的地点最好不是在办公室（因为一进去就感觉要聊工作），时间也最好不是工作高峰（避开上午10-12点，下午2-6点）。因为这些时间段老板往往会有很多会议安排，即使能挤出时间和你1v1，也可能心烦意乱不在状态。
我建议和老板安排1v1，可以选择早上9-10点的coffee chat或者中午12-2点的午休，在公司附近的餐厅。这样可以有一个相对远离严肃的办公环境，且不会被其他会议打扰的时间段。
2）准备好工作相关的话题
虽说和老板1v1不能做简单的工作汇报，但是完全不聊工作也是不可能的（要不岂不是变约会了，咳咳咳）。但是和老板1v1的时候如果只是流水账重复例会上讲过的工作汇报，或者毫无逻辑地谈论工作上的奇思妙想，都会让老板对你的工作能力和思考深度有担心。
具体应该怎么聊工作呢？有个万能公式，和大家分享下。
我之前在Kellogg读MBA的时候，有一次听一个美国头部消费品公司的VP来开讲座，聊起他是如何在大公司快速晋升的，分享了一个他和老板沟通的小秘诀。他无时无刻都准备好两个工作问题的答案，随时碰上大中小老板聊起工作，他都会用2分钟时间像背稿子一样抛出这两个答案。1）当前负责的工作，有哪些关键进展和业绩数据。2）对公司或自己团队还没开展的业务，有哪个自己看到的可以尝试的机会。
如果你每次和老板1v1的时候，都能迅速的抛出提前精选准备的以上两个问题的答案，那你在老板眼中，肯定能成为一个既熟悉自己手头工作，又有创新思路的可造之才。
3）让老板成为老师
除了工作以外的话题外，和老板1v1还可以准备一些自己关心且老板有能力/经验回答的问题，给老板一个成为你职场和人生导师的机会。这样聊下来，一来你能获得自我提升，二来老板会觉得每次和你1v1聊天都很开心（毕竟大家都喜欢讲自己擅长的东西的），能增加不少亲近感。
比如，找我来1v1的同学除了问我工作问题外，还会问些职业规划，申请海外MBA，旅游，甚至是带娃的问题。这些恰巧都是我（至少自己觉得）擅长的领域，每次都会回答得很带劲。
希望能帮助大家更高效地和老板1v1。
原文链接：和老板1v1要聊些啥？ 我有个习惯是和团队的核心成员每2周 - 即刻App
目前看，ai非常大的一个威胁是，提供给人类一种“思考幻觉”，在前ai时代，普通人和各领域精英间的一个普遍差异，是有没有结构化思考/结构化输出的能力
从r1和manus来看，ai应用最强的地方之一就是结构化能力——去拆解问题和任务，它拆完了之后，把这个结构化的过程展示出来，就给了用户一个我也能结构化的错觉
这对于已经有类似能力的老炮来说，没啥问题，省时间多好，但对于在成长期的学生和职场幼崽来说，如果完全用ai来替代结构化思考的部分，完全不去做从0到1的事情，会丧失掉这个学习提高的过程中附带的收益，也会潜在失去向更高阶思维能力（创造力-直觉-分析复杂问题）的攀登可能
就算从最基本的角度来看，也会至少丧失掉积累一些底层思维素材的机会，而且长期来看可能会让思维活性下降，表面上看，一些任务仍然可以完成，甚至通过ai展示的“思考过程”，认为自己仍然有做这些事的能力，但其实已经根本没法自己上手去做基础性的思考了，我觉得这可能是摆在这一代全球教育者和父母面前的一个特别大的挑战
再阐述得明白一点：
结构化思考有两个前提，第一个前提是，你习得/自己误到了一些思维方法论，比如说什么金字塔模型之类的玩意儿，第二个前提是，你必须真的对一些特定领域有一些基础理解和经验。
比如你让我去结构化核物理中的某个问题，或者去拆解航空航天中的某个技术问题，我就拆不好，再聪明再有方法论也不行。
这些基础理解和经验，是需要在面对一些具体问题的时候，做过一些从0到1的扎实思考和实践之后，才能积累出来，成为你脑子面对类似问题的一个“轮子”，而ai省掉的，就是这些“基础过程”，于是你脑子里扎实的轮子就少了。
再换种方式说，以我最近辩论的经验来看，一个积累不够的辩手，去找高手求助讨要论点，有时候是没有用的，因为高手给了某套论点，你也理解不透，吃不下来，就算掰开了揉碎了讲一遍，到了场上，还是表达不出来。因为这套论所需要的一些更细节更基础的前提，在高手心中有，但在你心里没有，他从0到1琢磨过一遍，你没有，他的轮子你没造出来，于是你就形不成那些周边的延展性的看上去更高级的思考，也禁不起对方的攻防检验
原文链接：目前看，ai非常大的一个威胁是，提供给人类一种“思考幻觉”， - 即刻App
本文分析了阿里巴巴股价近期大幅回升的原因，并探讨了未来股价可能的走势。阿里股价在2025年2月21日达到3年来的新高，主要驱动因素是市场对阿里云业务的价值重估。文章通过比较国际云服务商巨头的估值方式，提出了阿里云业务的合理估值水平。同时，随着AI技术的应用，阿里的传统业务也有望实现盈利模式的升级迭代。根据对云业务和非云业务的综合评估，阿里目前的股价估值范围大约在140美元到218美元之间。
松烟阁评论：主要让我之类怎么宏观的用一个计算模型评估企业的市值以及股票价格
原文链接：阿里的股票还会涨多少
“世界崩盘”保命指南
最近几天美股带崩了几乎全球市场，这时候要不要进去捡便宜? 华尔街有句经典谚语，“Don't catch a falling knife”，不要接飞刀
现在的病根是美联储过去几年疯狂印钞救市，现在通胀压不住只能加息，但加息加猛了经济会崩，不加息通胀崩，横竖都是死局
在这个背景下，华尔街大佬们现在正在互相捅刀对冲风险，作为散户的修养就是别跟着玩命，普通人跟着炒妖股、玩杠杆，大概率是韭菜命
所以，学学巴菲特老爷子，现金才是王道
市场崩起来谁也不知道底在哪，保住本金比啥都重要，尤其多囤黄金和现金，留足弹药，等市场真正恐慌暴跌再分批捡便宜货
切记，别加杠杆，别做空，更别玩期权（普通人根本玩不过机构和算法）
这期间尤其注意2个信号:
1，如果美联储突然降息或放水，可能是市场崩盘的信号，赶紧跑
2，哀股也别太自high，如果美股崩了，哀股大概率跟着跌（外资跑路+情绪传染），别迷信炒作的“独立行情”
记住，当世界崩盘的时候不要“接飞刀”，现在不是发财的时候，是保命的时候
最后，想起2020年写的一篇笔记，真真是“历史不会简单的重复，但总惊人的押韵”。如下:
华尔街有句经典谚语：Don’t catch a falling knife，“不要接飞刀。”
意思就是，股票如果正在连续下跌的时候，如果你非要去捡便宜，结局可能像接一把下落的刀一样把自己割伤。
其实应对办法是有的，之前读《大作手》的时候，一代枭雄利弗莫尔的操作方法就很适合——追涨杀跌+金字塔型投入
追涨杀跌？是的，你应该根据现在在上涨还是下跌的趋势，确定是否入场和离场，只在涨的时候进，跌的时候果断止损和观望，不要觉得自己是天选之子可以买在最低点，卖在最高点
金字塔投入? 意思是，你判断这个趋势是涨，但不确定是不是真趋势，怎么办？一点点的投，如果得到验证再一点点逐步加大筹码，就像金字塔的形状
好，最后你以为我在说金融? 其实金融里的决策，无非是你生活中的一个小小模型而已
原文链接：“世界崩盘”保命指南 最近几天美股带崩了几乎全球市场，这时 - 即刻App
这篇文章讲述了作者在英国留学期间与本地学生建立友谊的经历。通过参与壁球活动和参加苏格兰传统节日 Burns Night，作者与同学 Ryan 和 Bill 逐渐加深了彼此的了解。尽管文化差异带来了挑战，但这些经历让作者认识到跨越文化的友谊是可能且宝贵的。文章最后强调了理解和耐心对于建立跨文化友谊的重要性。
