关键词搜索在智能体工具选择上追平 8B 嵌入模型

智能体工具检索:BM25 与嵌入模型对比
你有没有过这样的经历:打开抽屉想找一把螺丝刀,却发现里面还塞着几百样别的东西?抽屉里只有十样东西时,你想都不用想就能拿到对的那把;而面对几百样东西,你得开始翻找,迟早会拿错。
智能体正走进同一个抽屉。MCP 让工具的安装变得如此简单,几台服务器就能交给你的智能体数百个工具,而每一次请求,它都必须先回答同一个问题:我该用哪一个?通常的建议是:工具还装得下时就把它们全部放进提示词,装不下时再改用检索。但没人告诉你的是,切换之后会发生什么。当你不断添加工具时,检索还撑得住吗,还是会慢慢崩掉?花更多钱换更大的模型有帮助吗?
这正是我想弄清楚的。于是我从 ToolRet [1]——一个公开的工具检索基准测试——中取出 200 个问题,在把工具堆不断扩大的过程中让这些问题保持完全不变,从 1,000 个工具一直加到 3,794 个。正确答案始终没有变,增长的只是它们周围的杂物。这样一来,如果某个方法表现变差,我们就知道是更大的工具堆造成的。
以下就是结果。随着工具堆变大,每一种方法都变差了,而且退步幅度大致相当,约为各自得分的五分之一。一套来自 1990 年代的纯关键词搜索,效果与体量是它 24 倍的嵌入模型相当,运行速度却快了数百倍。把每个工具都塞进提示词的做法,早在工具堆停止增长之前就已经装不下了。而唯一一项比换用更大模型更有效的改动,其实只是把完整的工具文档而不是一行摘要交给检索器。
代码、评测集以及每一次查询的结果都在 GitHub 上,如果你想复现其中任何一部分都可以。
ToolRet 把三十多个工具使用数据集汇总成约 7,600 个任务,覆盖 43,000 多个工具,每个任务都标注了能解决它的工具 [1]。它出现在 MCP 之前,也完全不是关于 MCP 的,但它测试的正是同一个问题。你有一个请求、一大堆工具,而你需要找出正确的那几个。
我用的是它的代码类别,其中有 3,794 个工具。选它有一个略显微妙的理由。它的工具描述足够冗长,以至于 Gemma 3 的 131,072 Token 上下文窗口在大约 2,500 个工具时就被填满了。这就把提示词方法失效的临界点正好放在实验的中段,于是我们能亲眼看到它发生。
这 200 个问题总共需要 186 个不同的工具。每一堆都包含全部 186 个,其余都是填充项:
同样那些正确的工具,被越来越多的垃圾埋住。图片来源:作者
工具堆里有多少是正确的
每一堆都是在前一堆的基础上叠加更多工具,因此逐行之间其他条件都不变。
为了给每种方法打分,我们看它的前十项选择,并问三个问题。正确工具有没有进入前十?这是 Recall@10。它是否排在靠前的位置,也就是智能体最可能用到它的地方?这是 nDCG@10,也是主指标。如果任务需要三个工具,这三个是否都进了前十?这是 Completeness@10,它很重要,因为一个只拿到三个工具中两个的智能体仍然完不成任务。
每个工具只展示其名称和一段简短描述,截断到 180 个字符。我们会在接近结尾时回头讨论这个选择,因为事实证明它的影响比任何模型都大。
为什么不干脆把所有工具都塞进提示词里?
这是大多数人首先会尝试的做法,而且这么想也合理。把整份目录粘贴进提示词,描述任务,然后让模型自己挑。不会有任何东西被误过滤掉,因为正确的工具始终就摆在它眼前。
我用 Gemma 3 12B 试过这种办法,通过 Ollama 在 M5 Pro 上本地运行,内存 48 GB。工具数量达到 1,000 个时,提示词为 53,160 Token,模型光读取它就花了 215 秒,之后才用 2.3 秒给出答案。按这个速度跑完四个装得下的工具堆里的 200 道题,大约需要 82 小时。所以我只测了几次查询就停下来了。这意味着我没有这种方法的准确率数据,也无法告诉你它在较小的工具堆上是否会胜过检索。
更大的问题在于空间。即便使用精简后的描述,完整的 3,794 个工具堆也约合 198,000 Token,远远超出 Gemma 3 的上下文窗口。如果用完整文档,连 1,000 个工具都装不下。无论 LLM 怎么做,它始终只能基于被裁剪过的工具描述来工作。这一点请记住,后面会用到。
如果你确实要走这条路,有两件事能让你少受点罪。第一,Ollama 的默认上下文窗口很小,当你的提示词更长时,它会悄悄从前面截掉 Token 然后照样给出答案,不报任何错误。把 num_ctx 设得足够大,并检查响应里的 prompt_eval_count,确认整份目录确实被读取了。第二,把目录放在前面,问题放在最后。目录每次都是一样的,所以模型可以缓存它,每次请求只需读取新问题。如果把问题放在最前面,那你每次都要付出完整的 215 秒。
def build_prompt(catalogue: str, query: str, instruction: str) -> str: # 把 catalogue 放在最前面,这样 KV 缓存就能在多次查询之间复用 task = f"TASK: {query}\nWHAT TO LOOK FOR: {instruction}" return PREAMBLE + catalogue + INSTRUCTIONS + task + "\n\nJSON:"
一个上下文窗口达到 100 万 Token 的托管模型确实能装下这一整堆内容,但每次请求都要为此付出代价。按我跑这套流程时的标价,对所有 3,794 个工具做一次未命中缓存的查询,在 Claude Opus 5 上花费约 $0.99,在 Sonnet 5 上约 $0.40。提示缓存能把这个数字大幅压低,但每次仍然要把整个目录发送出去。
BM25,外加针对代码的一处修正
BM25 [2] 是关键词搜索。它根据工具与问题共享的每个词为工具打分,稀有词得分更高,描述简短还有小幅加分。它不需要模型,也不需要 GPU。
不过这里有个陷阱。工具名本身就是代码,比如 get_factors 或 QueryHistoryToday。如果你按空格切分文本,get_factors 会保持为一个长词,而任何用平实英文提出的问题都不可能包含它。这个工具就会悄无声息地得零分——看起来像是搜索结果差,而不是一个 bug。解决办法是按下划线和大小写切分名称,同时保留原始名称:
_SPLIT = re.compile(r"[^A-Za-z0-9]+")_CAMEL = re.compile(r"(?<=[a-z0-9])(?=[A-Z])")def tokenize(text: str) -> list[str]: out = [] for chunk in _SPLIT.split(text): if not chunk: continue parts = [p.lower() for p in _CAMEL.sub(" ", chunk).split()] if len(parts) > 1: out.append(chunk.lower()) # 同时保留复合词 out.extend(parts) return [t for t in out if t not in STOPWORDS and len(t) > 1]
现在 get_factors 会被索引为 get_factors、get 和 factors,一个关于 factors 的问题就能找到它。BM25 的其余部分不过三十行标准代码,你可以在仓库里找到。
嵌入模型把每个工具、每个问题都转换成一串数字,数字与问题数字靠得近的工具胜出。好的一点是,用词不必一致。一个关于“找出一个数的因数”的问题,照样能落到一个“返回所有约数”的工具上。
我试了其中三个:BGE-large(335M 参数)[3]、e5-large-v2(335M)[4] 和 Qwen3-Embedding-8B [5],后者体积大 24 倍,需要 16 GB 内存。我们预先对每个工具编码一次,此后每个问题只需一次编码和一次快速乘法。
model = SentenceTransformer("BAAI/bge-large-en-v1.5", device="mps") tool_vectors = model.encode(texts, normalize_embeddings=True) # 每个语料库只编码一次 def search(query, k=10): q = model.encode(QUERY_PREFIX + query, normalize_embeddings=True) scores = tool_vectors @ q # 余弦相似度,因为两侧都已归一化 top = np.argpartition(-scores, k)[:k] return [tool_ids[i] for i in top[np.argsort(-scores[top])]]
有一点很容易被忽略:每个模型系列都要求在文本前面加上自己的那点小前缀,用错了会在没有任何提示的情况下掉分。
Represent this sentence for searching relevant passages:
Qwen3-Embedding 及其他基于 LLM 的嵌入模型
Instruct: {task}\nQuery:
如果你打算靠模型名字来挑前缀,先看最具体的名字。e5-mistral-7b-instruct 名字里带着“e5”,但它要的是 instruct 格式,而不是 E5 的那套。
嵌入模型从不会把问题和工具放在一起看。它把两者分别转成数字,然后指望它们最终靠得足够近。cross-encoder 则把两者并排读取,为这一对给出一个分数,这个分数理应更精准。问题在于,它每给一个工具打分都要运行一次,所以我们没法把它直接对准整个工具堆。于是改成:先用 BGE-large 取出排名前 50 的工具,再让 cross-encoder(bge-reranker-v2-m3)只对这 50 个重新排序。
reranker = CrossEncoder("BAAI/bge-reranker-v2-m3", device="mps", max_length=512)def two_stage(query, k=10, depth=50): candidates = search(query, k=depth) scores = reranker.predict([(query, text_by_id[c]) for c in candidates]) return [c for _, c in sorted(zip(scores, candidates), reverse=True)][:k]
原文较长,译文为节选;译文由英文原文机器翻译,术语按行业惯例统一,可在文末展开原文核对。
查看英文原文(Keyword Search Tied an 8B Embedding Model at Picking Agent Tools)
BM25 vs. Embedding Models for Agent Tool Retrieval
Have you ever opened a drawer looking for one screwdriver and found a few hundred other things crammed in there? With ten things in the drawer you grab the right one without thinking. With a few hundred, you start digging, and sooner or later you grab the wrong one.
Agents are heading into the same drawer. MCP has made tools so easy to install that a few servers can hand your agent hundreds of them, and on every request it has to answer the same question first: which one do I use? The usual advice is to put all the tools in the prompt while they fit, and switch to retrieval once they don't. What nobody tells you is what happens after that switch. Does retrieval hold up as you keep adding tools, or does it slowly fall apart? And does paying for a bigger model help?
That's what I wanted to find out. So I took 200 questions from ToolRet [1], a public benchmark for tool retrieval, and kept them exactly the same while I kept making the pile bigger, from 1,000 tools all the way up to 3,794. The right answers never moved. Only the amount of junk around them grew. That way, if a method gets worse, we know the bigger pile did it.
Here's what came out of it. Every method got worse as the pile grew, and by roughly the same amount, about a fifth of its score. A plain keyword search from the 1990s kept up with an embedding model 24 times its size while running hundreds of times faster. Putting every tool in the prompt ran out of room long before the pile stopped growing. And the one change that helped more than a bigger model was simply giving the retriever the full tool documentation instead of a one-line summary.
The code, the eval set and every per-query result are on GitHub if you want to rerun any of it.
ToolRet pulls together more than thirty tool-use datasets into about 7,600 tasks over 43,000 tools, and each task is labelled with the tools that solve it [1]. It came out before MCP and isn't about MCP at all, but it tests the exact same problem. You have a request, a big pile of tools, and you need to find the right ones.
I used its code category, which has 3,794 tools. I picked it for a slightly sneaky reason. Its tool descriptions are wordy enough that Gemma 3's 131,072-token context window fills up at about 2,500 tools. That puts the point where the prompt approach breaks right in the middle of the experiment, so we get to watch it happen.
The 200 questions need 186 different tools between them. Every pile contains all 186, and the rest is filler:

The same right tools, buried under more and more junk. Image by author
How much of the pile is right
Each pile is the previous one with more tools added on top, so nothing else changes from row to row.
To score each method we look at its top ten picks and ask three questions. Did the right tool make the top ten at all? That's Recall@10. Was it near the top, where the agent is most likely to use it? That's nDCG@10, the main score. And if the task needed three tools, did all three make it? That's Completeness@10, and it matters because an agent with two out of three tools still can't finish the job.
Each tool is shown as just its name and a short description, trimmed to 180 characters. We'll come back to that choice near the end, because it turns out to matter more than any model.
Why not just put every tool in the prompt?
This is what most people do first, and it makes sense. Paste the whole catalogue into the prompt, describe the task, and let the model pick. Nothing gets filtered out by mistake, because the right tool is always right there in front of it.
I tried this with Gemma 3 12B running locally through Ollama on an M5 Pro with 48 GB of memory. At 1,000 tools the prompt is 53,160 tokens, and the model took 215 seconds just to read it before spending 2.3 seconds on the answer. Doing that for 200 questions across the four piles that fit would take about 82 hours. So I timed a few queries and stopped there. That means I don't have accuracy numbers for this approach, and I can't tell you whether it would have beaten retrieval on the smaller piles.
The bigger problem is space. The full 3,794-tool pile comes to about 198,000 tokens even with the trimmed descriptions, which is well past Gemma 3's window. With the full documentation it doesn't even fit at 1,000 tools. Whatever the LLM does, it always works from a cut-down description of its tools. Keep that in mind for later.
If you do go this route, two things will save you some pain. First, Ollama's default context window is small, and when your prompt is longer it quietly chops tokens off the front and answers anyway, with no error. Set num_ctx big enough and check prompt_eval_count in the response to make sure the whole catalogue was actually read. Second, put the catalogue first and the question last. The catalogue is the same every time, so the model can cache it and only read the new question on each request. Put the question first and you pay the full 215 seconds every single time.
def build_prompt(catalogue: str, query: str, instruction: str) -> str: # catalogue first so the KV cache is reused across queries task = f"TASK: {query}\nWHAT TO LOOK FOR: {instruction}" return PREAMBLE + catalogue + INSTRUCTIONS + task + "\n\nJSON:"
A hosted model with a 1M-token window can fit the whole pile, but you pay for it on every request. At the list prices when I ran this, one uncached query over all 3,794 tools cost about $0.99 on Claude Opus 5 and $0.40 on Sonnet 5. Prompt caching brings that down a lot, but you're still sending the whole catalogue each time.
BM25, with one fix for code
BM25 [2] is keyword search. It gives a tool points for every word it shares with the question, more points for rare words, and a small bonus for short descriptions. There's no model and no GPU.
There's one trap here, though. Tool names are code, like get_factors or QueryHistoryToday. If you split text on spaces, get_factors stays one long word, and no question in plain English will ever contain it. The tool just quietly scores zero, which looks like a bad result rather than a bug. The fix is to split names on underscores and capital letters, and keep the original too:
_SPLIT = re.compile(r"[^A-Za-z0-9]+")_CAMEL = re.compile(r"(?<=[a-z0-9])(?=[A-Z])")def tokenize(text: str) -> list[str]: out = [] for chunk in _SPLIT.split(text): if not chunk: continue parts = [p.lower() for p in _CAMEL.sub(" ", chunk).split()] if len(parts) > 1: out.append(chunk.lower()) # keep the compound too out.extend(parts) return [t for t in out if t not in STOPWORDS and len(t) > 1]
Now get_factors gets indexed as get_factors, get and factors, and a question about factors can find it. The rest of BM25 is about thirty lines of standard code, which you'll find in the repo.
An embedding model turns every tool and every question into a list of numbers, and tools whose numbers sit close to the question's numbers win. The nice part is that the words don't have to match. A question about "finding the factors of a number" can still land on a tool that "returns all divisors".
I tried three of them: BGE-large (335M parameters) [3], e5-large-v2 (335M) [4] and Qwen3-Embedding-8B [5], which is 24 times bigger and needs 16 GB of memory. We encode every tool once up front, and after that each question is a single encode and a quick multiply.
model = SentenceTransformer("BAAI/bge-large-en-v1.5", device="mps")tool_vectors = model.encode(texts, normalize_embeddings=True) # once per corpusdef search(query, k=10): q = model.encode(QUERY_PREFIX + query, normalize_embeddings=True) scores = tool_vectors @ q # cosine, since both sides are normalised top = np.argpartition(-scores, k)[:k] return [tool_ids[i] for i in top[np.argsort(-scores[top])]]
One thing that's easy to miss: each model family expects its own little prefix in front of the text, and using the wrong one costs you points without any warning.
Represent this sentence for searching relevant passages:
Qwen3-Embedding and other LLM-based embedders
Instruct: {task}\nQuery:
If you pick the prefix by looking at the model's name, check the most specific names first. e5-mistral-7b-instruct has "e5" in its name, but it wants the instruct format, not E5's.
An embedding model never looks at the question and the tool together. It turns each one into numbers separately and hopes they end up close. A cross-encoder reads the two side by side and gives the pair a score, which should be sharper. The catch is that it has to run once for every tool it scores, so we can't point it at the whole pile. Instead, BGE-large grabs its top 50, and the cross-encoder (bge-reranker-v2-m3) reorders just those.
reranker = CrossEncoder("BAAI/bge-reranker-v2-m3", device="mps", max_length=512)def two_stage(query, k=10, depth=50): candidates = search(query, k=depth) scores = reranker.predict([(query, text_by_id[c]) for c in candidates]) return [c for _, c in sorted(zip(scores, candidates), reverse=True)][:k]
The reranker can only shuffle what it's given. If the right tool isn't in those 50, it's gone for good.
You might wonder why I didn't fine-tune a model, since ToolRet comes with 200,000 training examples. The problem is that those examples come from the same datasets as the test questions, so a fine-tuned model would partly be learning the test. There's also a practical reason. Every time you install a new server, a fine-tuned model has to be retrained to know about its tools, while BM25 and an off-the-shelf embedder can search a new tool the moment you add it.
Result 1: everything gets worse, and at about the same speed
nDCG@10 with the trimmed tool text, 200 questions.
Remember, the questions and answers are identical in every row. The only thing that changed is how much junk we added, and every single method slid down. Going from 1,000 to 3,794 tools cost BGE-large 0.118, BM25 0.128, the reranker 0.139 and Qwen3-8B 0.151. Those drops are solid, not noise. I resampled the questions 10,000 times, and every drop stayed above 0.09.
None of the lines level off, either. Retrieval wears down a little with every tool you add. Compare that with the prompt approach, which works fine until the catalogue doesn't fit, and then doesn't work at all. One fades slowly and the other falls off a cliff.
The surprise was Qwen3-8B. It started on top and fell the furthest, so by the full pile its lead was gone. Being 24 times bigger didn't make it any better at ignoring the extra junk.
Result 2: a bigger model cost more but didn't score higher
On the full pile, BM25, BGE-large, Qwen3-8B and the rerank pipeline all land between 0.481 and 0.494. Honestly, with 200 questions those are ties. When I resampled, the gap between BM25 and BGE-large could just as easily have gone either way, and the same was true for Qwen3-8B. Only e5-large-v2 was clearly behind. This lines up with what the ToolRet authors found across their whole benchmark, where BM25 and BGE-large also ended up close together [1].
Where they really differ is cost:
Everything in the prompt
So for the same accuracy, BM25 answers about 40 times faster than BGE-large and about 2,000 times faster than the rerank pipeline, and it doesn't need a GPU at all.
This one confused me at first. The reranker got the right tool into the top ten more often than BGE-large on its own, on every pile. At 1,000 tools, Recall@10 went from 0.742 to 0.798, and at 3,794 from 0.604 to 0.641. But its nDCG was lower on four of the five piles. How can both be true?
It pulled the right tools up from somewhere in positions 11 to 50 into the top ten, but then it put them in a worse order than BGE-large had. And it wasn't short of material. The right tools were in its top 50 between 79% and 90% of the time, so most of the answers were sitting right there. It only recovered 8% to 36% of that room. Faced with fifty tools that all sound alike, a general-purpose reranker couldn't reliably tell which one was right.
Result 4: better descriptions helped more than a bigger model
Remember the trimmed descriptions? We only trimmed them because the LLM needed them short. Retrieval has no such limit, so I ran BM25 and BGE-large again on the full tool documentation, including the parameter details. Tang and colleagues argue that how you describe a tool matters as much as which retriever you use [6], and this is the simplest way to test that.
The full documentation wins in every single row, by about 0.02 to 0.04. That's roughly the same boost Qwen3-8B gave over BGE-large on the smallest pile, except here you don't need a 16 GB model to get it. I want to be careful, though. Because the piles overlap, those ten wins aren't ten separate experiments, and only a couple of them clearly hold up on their own when I resample, BM25's gain on the full pile being one. The direction is consistent, but the exact size is fuzzy.
BM25 on the full documentation was the best setup I tested, with 0.533 nDCG on the full pile at about a millisecond per question. I didn't run Qwen3-8B or the reranker on the full documentation, though, so I can't claim BM25 beats them there. My guess is they'd improve too.
This also makes the prompt approach look a bit worse. The text that helped retrieval the most is exactly the text the LLM can't fit.
What does it mean for your agent?
An nDCG of 0.53 sounds okay. So here's the same result put another way. With 3,794 tools, even the best setup got every tool a task needed into the top ten only 65% of the time. On the other 35% of tasks, the agent was missing at least one tool before it even started. Qwen3-8B managed 60% and BGE-large 56%. That's a lot of tasks that fail before the agent does anything at all.
What this experiment can't tell you
The code category is friendly to keyword search. A lot of tool names here literally say what they do, like get_factors, so a question and the right tool tend to share words. On a catalogue full of vague or branded names, embeddings might pull ahead. ToolRet's web and customized categories would be the place to check.
Each question also comes with an instruction that ToolRet wrote using GPT-4o. That adds extra words to every question, which probably helps BM25 more than the embedding models. I haven't run it without the instruction yet.
Two hundred questions isn't a lot, which is why I keep calling most of the gaps ties. And the absolute numbers don't line up with the ToolRet paper's own leaderboard, which uses all 43,000 tools across every category. What carries over is the shape of the curves, not the exact scores.
Finally, there's plenty I didn't try: mixing BM25 and embeddings into a hybrid search, a reranker trained on tool data, or measuring how accurate the LLM actually is on the piles where it fits. Hybrid search is the first thing I'd try next.
If your agent has a few dozen tools, don't bother with any of this. Put them all in the prompt and let the model choose. Once you're into the hundreds, retrieve first. And expect it to get a bit worse with every tool you add. In this experiment it was about 0.04 nDCG for every extra thousand.
For the retriever itself, I'd start with BM25 on the full tool documentation, with a tokenizer that splits code-style names. It kept up with models up to 24 times its size, runs in under a millisecond on a CPU, and can find a new tool the moment you add it. If you have time to spend on making tool selection better, spend it on the tool names and descriptions before you spend it on a bigger model. Better text helped about as much as the bigger model did, and it's much cheaper.
Even the best setup missed a tool it needed on about a third of the tasks, so this problem is far from solved. It's worth knowing that before you trust any tool picker blindly.
All the code, the eval set and the per-question results are at github.com/ankur287/toolret-tool-retrieval.
[1] Z. Shi, Y. Wang, L. Yan, P. Ren, S. Wang, D. Yin and Z. Ren, Retrieval Models Aren't Tool-Savvy: Benchmarking Tool Retrieval for Large Language Models (2025), Findings of ACL 2025, arXiv:2503.01763
[2] S. Robertson and H. Zaragoza, The Probabilistic Relevance Framework: BM25 and Beyond (2009), Foundations and Trends in Information Retrieval
[3] S. Xiao, Z. Liu, P. Zhang, N. Muennighoff, D. Lian et al., C-Pack: Packed Resources For General Chinese Embeddings (2023), arXiv:2309.07597
[4] L. Wang, N. Yang, X. Huang, B. Jiao, L. Yang et al., Text Embeddings by Weakly-Supervised Contrastive Pre-training (2022), arXiv:2212.03533
[5] Y. Zhang, M. Li, D. Long, X. Zhang, H. Lin et al., Qwen3 Embedding: Advancing Text Embedding and Reranking Through Foundation Models (2025), arXiv:2506.05176
[6] Y. Tang, W. Su, Y. Liu and Q. Ai, Multi-Field Tool Retrieval (2026), arXiv:2602.05366
The reliability mechanisms we add to LLM pipelines are often the ones that make them confidently wrong.
September 24, 202610 min read
Enterprise Document Intelligence [Vol.1 #14B] - No shared fields means no index to build. One summary line per file plus each file’s own table of contents, and retrieval routes down two levels
August 22, 202616 min read
A practical guide to understanding AI agent design, ReAct workflows, and when to scale from a single agent to a multi-agent system.
How to leverage a framework to effectively prioritize AI Initiatives to rapidly accelerate growth and efficiency
March 24, 202625 min read
Why tool discovery is solved, but tool execution isn’t.
September 5, 202514 min read
Enterprise Document Intelligence [Vol.1 #7C] - One LLM call ranks the candidates with reasons. The output is one typed object your auditor can defend
June 25, 202626 min read
I saved my day with a mere $52 bill. But you don't have to repeat my mistake.
September 7, 20266 min read
And what ORPilot does differently
Enterprise Document Intelligence [Vol.1 #5sexies] - image_df tells you where every picture is. Turning the few that matter into searchable text is a separate, cost-ordered job
June 20, 202614 min read
原文为英文,正文由自动抓取并保留原文。
原文发布于 Towards Data Science(Keyword Search Tied an 8B Embedding Model at Picking Agent Tools),标题、摘要与正文由机器翻译,术语按行业惯例统一,未经人工逐句校订。