How Perplexity Built Their Search EnginePerplexity 如何构建他们的搜索引擎

The architecture behind 30 million cited answers a day.30 万条被引用答案的背后架构

🧭 Part 8 of the RAG & Search course🧭 RAG 与搜索课程第 8 章

Perplexity answers questions instead of returning links by owning its retrieval end to end: a crawler, an index of hundreds of billions of pages, a hybrid ranking funnel that ends in cross-encoder rerankers, and the Sonar model writing answers with a citation on every sentence and nothing it did not retrieve.Perplexity 通过拥有端到端的检索流程来回答问题，而不是返回链接：爬虫、数十亿页面的索引、以交叉编码器重排序为终点的混合排名漏斗，以及 Sonar 模型在每个句子上写出引用并且只使用检索到的内容来回答问题。

The Pain

痛点

Ask a coding assistant for a library and it will hand you a clean install command for a package that does not exist. One 2025 study ran 16 models across 576,000 code samples and found that nearly one in five recommended packages were hallucinated, invented names that looked just like real ones¹. Attackers noticed: register the fake name, and the next developer who pastes the suggestion installs whatever you uploaded. The model was fluent and wrong at the same time, and nothing in it could tell the two apart. That is the failure mode of a model answering from memory: it generates a confident answer because that is what it was trained to do.向编码助手询问库，它会给你一个不存在的包的干净安装命令。2025 年的一项研究在 576,000 个代码样本上运行了 16 个模型，发现近五分之一推荐的包是幻觉，发明了看起来像真实名称的名字¹。攻击者注意到：注册这个假名，下一个粘贴建议的开发者会安装你上传的任何东西。模型既流利又错误，且其中没有任何东西能区分两者。这就是从记忆中回答的模型的失败模式：它生成自信的答案，因为那是它被训练去做的。

The older way of answering has the opposite problem. Ask a search engine and it hands you ten blue links. Three of them hold pieces of the answer, the other seven are dead ends, and the reading and stitching are your job. One approach makes things up; the other makes you do the work. An answer engine has to beat both.旧的回答方式有相反的问题。向搜索引擎提问，它会给你十个蓝色链接。三条包含答案片段，另外七条是死胡同，阅读和拼接是你的工作。一个方法会编造东西；另一个让你做工作。答案引擎必须击败两者。

TL;DR

TL;DR

• Perplexity is an answer engine: ask a question, get a written answer with a footnote on every sentence, drawn from pages it just read. By May 2025 it was fielding around 30 million of those a day².Perplexity 是一个答案引擎：提问，得到带有每句脚注的书面答案，来源于它刚刚阅读的页面。到 2025 年 5 月，它每天处理约 3,000 万个此类请求²。

• The core rule is strict grounding: the model may only say what the search layer retrieved, and must cite it. No supporting source, no claim. If the sources fall short, it is supposed to say so rather than guess.核心规则是严格的根植：模型只能说检索层检索到的内容，并且必须引用。没有支持来源就不能提出主张。如果来源不足，模型应该说明，而不是猜测。

• The stack is built in-house: its own crawler, its own index of hundreds of billions of pages, and a retrieval engine running on Vespa, because that rule only pays off if retrieval is excellent.该堆栈由内部构建：自己的爬虫、数十亿页面的索引，以及在 Vespa 上运行的检索引擎，因为只有检索优秀时该规则才有价值。

• Ranking is a funnel. Cheap lexical and embedding scorers skim a vast candidate pool, then expensive cross-encoder rerankers re-read the survivors, all inside a budget of about 100 milliseconds.排名是一个漏斗。廉价的词汇和嵌入评分器先筛选庞大的候选池，然后昂贵的交叉编码器重排序器重新阅读幸存者，全部在约 100 毫秒的预算内完成。

• Hard questions get decomposed: the Pro Search planner splits a question into sub-queries, retrieves for each, then synthesizes. That loop is what separates an answer engine from one-shot RAG.难题会被拆解：Pro Search 规划器将问题拆分为子查询，为每个检索，然后综合。这个循环是答案引擎与一次性 RAG 的区别。

• Sonar writes the answer: an in-house model fine-tuned from Llama 3.3 70B for factuality, served on Cerebras hardware at 1,200 tokens a second.Sonar 写答案：内部模型，基于 Llama 3.3 70B 微调以提升事实性，在 Cerebras 硬件上以每秒 1,200 个 token 运行。

Before Perplexity: Answers from Memory

Perplexity 之前：记忆中的答案

There are two ways to answer a question: recite it from memory, or look it up. Perplexity bet everything on the second.回答问题有两种方式：从记忆中背诵，或去查找。Perplexity 把一切赌在后者上。

To see why, start with the first way. A raw large language model answers closed-book, from memory: everything it knows was baked into its weights during training, so when you ask it something it is reciting a compressed memory of the internet as it looked months ago. That works until the question needs a fact that is recent, niche, or simply was not memorized well, and then the model does the worst possible thing. It writes a fluent answer anyway. It is not trained to flag the difference between a fact it verified and a string that is merely statistically plausible, and it will not stop to say “I am unsure.”要了解原因，先看第一种方式。原始大型语言模型在闭卷模式下回答：它知道的一切都已在训练期间烘焙进权重中，因此当你问它某事时，它在回忆几个月前的互联网压缩记忆。直到问题需要最近、专业或根本未被很好记忆的事实时，它才会表现最差。它仍会写出流利的答案。它没有训练去区分已验证的事实和仅仅统计上可行的字符串，也不会停下来说“我不确定”。

The second way is to look it up. Retrieval-augmented generation, or RAG, turns the test into an open-book exam. We covered the full mechanism in What is RAG?, but the one-line version is: before the model writes anything, you run a search, pull the specific passages that bear on the question, and paste them into the prompt. Now the model answers with the notes in front of it. Aravind Srinivas, Perplexity’s CEO, uses exactly that framing: you want a system that learns the way a student does in an open-book exam, with the source material on the desk instead of in their head.第二种方式是去查找。检索增强生成（RAG）将测试变成开放式考试。我们在《什么是 RAG？》中完整介绍了机制，但一句话版本是：在模型写任何东西之前，你先运行搜索，提取与问题相关的具体段落，然后将它们粘贴到提示中。Perplexity 的 CEO Aravind Srinivas 正是用这种框架：你想要一个像学生在开放式考试中学习的系统，桌面上有源材料而不是记忆。

That open-book framing is what the rest of the architecture serves. A search engine on its own gives you links and leaves the reading to you. A model on its own gives you fluent guesses. Combine them well and the answer comes back written and checkable. That is the whole engineering problem Perplexity solved.这种开放式框架是其余架构服务的基础。单独的搜索引擎给你链接，留给你阅读。单独的模型给你流利的猜测。将它们很好地结合，答案就会以书面、可检查的形式返回。这就是 Perplexity 解决的整个工程问题。

Why Perplexity Went In-House

为什么 Perplexity 选择内部构建

Most RAG treats retrieval as a quick step: call a search API, grab some snippets, move on. Perplexity cannot work that way, because for an answer engine retrieval is the whole product. Srinivas breaks hallucination into four causes, and only one is the model being dim:大多数 RAG 将检索视为快速步骤：调用搜索 API，抓取片段，然后继续。Perplexity 无法那样工作，因为对答案引擎而言，检索是整个产品。Srinivas 将幻觉拆分为四个原因，只有一个是模型本身的薄弱：

1. the model misreads a good passage;模型误读了好段落；

2. the index serves a stale or thin snippet;索引提供了陈旧或薄弱的片段；

3. the search returns documents that do not contain the answer; or 搜索返回不包含答案的文档；或

4. the prompt gets stuffed with so much irrelevant text that the model loses the thread提示被大量无关文本淹没，导致模型失去线索

Three of the four live in retrieval, so fixing the model alone addresses just one, arguably the least decisive, because the other three feed it³.四个原因中有三个存在于检索层，因此仅修复模型只能解决其中一个，且最不决定性，因为其他三个会喂给它。

That is why Perplexity owns its retrieval instead of renting it. In April 2025 it announced it had pulled its search function in-house and rebuilt it on Vespa, an open-source engine that does retrieval, ranking, and machine-learning inference in one serving layer. Underneath it runs PerplexityBot, Perplexity’s own crawler, alongside third-party crawlers it also licenses. The output is a proprietary index that Perplexity describes as covering hundreds of billions of webpages, kept fresh by tens of thousands of index updates every second⁴.这就是 Perplexity 拥有检索而不是租用的原因。2025 年 4 月，它宣布已将搜索功能内部化，并在 Vespa 上重建——一个开源引擎，能够在一个服务层完成检索、排名和机器学习推理。其下运行的是 PerplexityBot，Perplexity 自己的爬虫，以及它也授权的第三方爬虫。输出是一个专有索引，Perplexity 描述为覆盖数十亿网页，通过每秒数万次索引更新保持新鲜度⁴。

That last number is worth pausing on, because it is easy to misread. Tens of thousands of updates a second is a write rate, the speed at which new and changed pages enter the index. It is not the query rate. The point of pushing it that high is freshness: when a question is about something that happened an hour ago, the page describing it is already searchable. For a closed-book model, an hour-old event does not exist.这个最后的数字值得停下来思考，因为很容易误读。每秒数万次更新是写入速率，即新旧页面进入索引的速度。它不是查询速率。将其推到这么高的目的是保持新鲜度：当问题涉及一小时前发生的事时，描述它的页面已经可搜索。对于闭卷模型，一小时前的事件根本不存在。

⚠️ Confusion Alert: Perplexity is often dismissed as a wrapper on Google’s index. That is wrong. It runs its own crawler and its own index, the same one it now sells through its Search API. It does also license third-party crawlers, so the honest description is hybrid sourcing over an index it owns, which is a different thing from reselling someone else’s search results.⚠️ 混淆警报：Perplexity 经常被误认为是 Google 索引的包装器。这是错误的。它运行自己的爬虫和自己的索引，即它现在通过搜索 API 销售的同一索引。它也授权第三方爬虫，因此诚实的描述是对其拥有的索引进行混合来源，而不是转售他人搜索结果。

The Architecture

架构

Perplexity’s pipeline turns a question into a set of cited passages, then has a model write the answer from those passages and nothing else.Perplexity 的管道将问题转化为一组引用段落，然后让模型从这些段落中写答案，且不使用其他内容。

Walk the request end to end. A question comes in. The retrieval layer searches the index and pulls candidate passages; a ranking funnel narrows them from a flood to a handful; the survivors get assembled into a prompt alongside the question; Sonar writes an answer with a footnote on every sentence. The whole round trip takes about a second, roughly 100 milliseconds of retrieval and the rest Sonar writing, which streams as it goes.从请求端到端走一遍。问题进来。检索层搜索索引并拉取候选段落；排名漏斗将它们从洪流缩小到少数；幸存者与问题一起组装成提示；Sonar 写答案，每句都有脚注。整个往返大约一秒，约 100 毫秒用于检索，其余时间 Sonar 写作，边写边流式输出。

The pipeline has three parts: how it indexes, how it ranks, and how it writes.管道有三部分：索引方式、排名方式和写作方式。

The index stores meaning alongside words. Every document Perplexity crawls is indexed twice over: once as ordinary text for keyword matching, and once as a set of vector embeddings, numerical coordinates that place a passage by meaning so that “how do I lower my blood sugar” can match a paragraph on glucose management that shares no keywords with the query. We unpacked that idea in What are Embeddings?. The unit of indexing is the sub-document chunk rather than the whole page: Perplexity splits documents into fine-grained pieces and scores each on its own, so one relevant paragraph buried in a long article can surface without dragging the surrounding few thousand words into the prompt. That defuses Srinivas’s fourth hallucination cause, the prompt drowning in noise.索引将意义与词语一起存储。Perplexity 爬取的每个文档都被两次索引：一次是普通文本用于关键词匹配，另一次是向量嵌入集合，数值坐标按意义定位段落，使得“如何降低血糖”可以匹配一段关于葡萄糖管理的段落，即使查询中没有任何关键词。我们在《什么是嵌入？》中拆解了这个想法。索引单元是子文档块，而不是整页：Perplexity 将文档拆分为细粒度片段，并单独评分，因此长文章中一个相关段落可以浮现，而不必把周围几千字拉进提示。这样就消除了 Srinivas 的第四个幻觉原因——提示被噪声淹没。

Retrieval is hybrid, and ranking is a funnel. Perplexity does not choose between keyword search and semantic search; it runs both and fuses the scores, the approach we compared in What is Semantic Search?. Keyword matching nails exact terms, names, and error codes; embedding matching catches meaning when the words differ. Then the candidates fall through progressively more expensive stages. Early stages use fast lexical and embedding scorers to cut a huge candidate pool down to a working set. Later stages bring in cross-encoder rerankers, models that read the query and a candidate passage together and judge their fit far more accurately than a vector-distance score can, because the two texts attend to each other directly.检索是混合的，排名是漏斗。Perplexity 不在关键词搜索和语义搜索之间做选择；它同时运行两者并融合得分，这是我们在《什么是语义搜索？》中比较的做法。关键词匹配精准抓取确切术语、名称和错误代码；嵌入匹配捕捉词不相同但意义相同的情况。随后候选者逐步进入更昂贵的阶段。早期阶段使用快速词汇和嵌入评分器将庞大候选池缩小到工作集；后期阶段引入交叉编码器重排序器，模型同时读取查询和候选段落，并比向量距离得分更准确地判断匹配度，因为两段文本直接相互关注。

Generation runs on a tight leash. The retrieved passages and the question go to Sonar, Perplexity’s in-house answer model, fine-tuned from Meta’s Llama 3.3 70B for factuality and tight, readable answers. Fine-tuning is the lever we covered in What is Fine-Tuning?: start from a strong open model, then train it further on the narrow job you actually have, which here is “write a concise, sourced answer from these passages.” Sonar attaches a citation to every sentence and draws only from the supplied passages. Serving runs on Cerebras wafer-scale hardware at 1,200 tokens a second, so the answer streams out about as fast as you can read it⁵.生成在紧绷的束缚下运行。检索到的段落和问题送到 Sonar，Perplexity 内部答案模型，基于 Meta 的 Llama 3.3 70B 微调以提升事实性和紧凑、可读答案。微调是我们在《什么是微调？》中讨论的杠杆：从强大的开放模型开始，然后在你实际拥有的狭窄任务上进一步训练，这里是“从这些段落写简洁、引用答案”。Sonar 为每句附上引用，只从提供的段落中提取。服务在 Cerebras wafer-scale 硬件上以每秒 1,200 个 token 运行，因此答案流式输出速度与阅读速度相当⁵。

🔍 Deeper Look: Vespa’s engineering team wrote up the production shape of this system in Perplexity builds AI Search at scale on Vespa.ai, and Perplexity’s own engineers detailed the ranking stages in a companion post. Key line: early stages use lexical and embedding scorers for speed, then “more powerful cross-encoder reranker models” sculpt the final order.🔍 深入了解：Vespa 的工程团队在《Perplexity 在 Vespa.ai 上以规模构建 AI 搜索》一文中记录了此系统的生产形态，Perplexity 自己的工程师在配套文章中详细说明了排名阶段。关键一句话：早期阶段使用词汇和嵌入评分器以提升速度，然后“更强大的交叉编码器重排序模型”雕刻最终顺序。

When One Search Is Not Enough

单一搜索不够用时

The pipeline above is the single-hop path: one question, one retrieval, one answer. Plenty of real questions do not fit it. Ask “what is the educational background of the founders of LangChain” and a single search fails, because you first have to learn who the founders are before you can look up where each studied.上述管道是单跳路径：一个问题，一个检索，一个答案。许多真实问题不适合它。问“LangChain 创始人的教育背景是什么”，单一搜索失败，因为你首先必须了解创始人是谁，然后再去查每个人的学习地点。

Perplexity’s Pro Search mode handles that with a planner that separates planning from execution. It first writes a plan, breaking the question into sub-queries. Then it runs them in sequence, and the results of the early steps shape the searches in the later ones: find the founders, then fan out a fresh retrieval for each name. The documents from every step are pooled, ranked, and filtered down to the strongest, and only then does the answer model synthesize across all of them. It is the same retrieve-rank-ground machinery from the single-hop path, wrapped in a loop that runs it several times and feeds each pass into the next⁶.Perplexity 的 Pro Search 模式使用规划器处理这类问题，规划器将规划与执行分离。它首先写出计划，将问题拆分为子查询。然后按顺序运行它们，早期步骤的结果塑造后续搜索：先找创始人，然后为每个名字进行新的检索。每一步的文档被汇总、排名，并筛选到最强的，只有此时答案模型才会跨所有文档综合。它是单跳路径的相同检索-排名-根植机制，包装在一个循环中多次运行并将每次传递给下一次⁶。

This is the part that earns the name “answer engine” over “RAG demo.” One-shot RAG can only answer what a single query surfaces; a planner that decomposes and retrieves iteratively can chase a question whose parts depend on each other. The cost is latency and fragility: every extra hop is another retrieval round and another chance for an early wrong turn to poison the final answer, which is why planning is treated as its own problem rather than bolted onto generation.这就是获得“答案引擎”而非“RAG 演示”名称的原因。一次性 RAG 只能回答单个查询检索到的内容；规划器逐步拆解并检索的方式可以追踪相互依赖的子问题。代价是延迟和脆弱性：每多一次跳就多一次检索回合和一次早期错误导致最终答案被污染的机会，这也是为什么规划被视为独立问题而不是附加到生成上的原因。

The Decisions That Mattered

关键决策

Three engineering decisions shaped the design. Take them from the most foundational to the most operational.三项工程决策塑造了设计。从最基础到最操作化的顺序来看看。

Decision 1: cite every sentence or refuse. Vanilla RAG adds retrieved context and lets the model write, leaving it free to lean on memorized knowledge. Perplexity tightens the rule: in Srinivas’s words, the model is not supposed to say anything it did not retrieve, and is told to use nothing beyond the retrieved passages. If the sources are thin, the correct output is “I do not have enough information.” The model Perplexity borrows is academic and Wikipedia writing, where every claim needs a citation to a notable source and anything uncited is treated as opinion. The tradeoff is real and they accept it: a strictly grounded engine will sometimes refuse a question a chattier model would answer, because the sources did not cover it. The payoff is that when it does answer, you can click the footnote and check.决策 1：引用每一句或拒绝。普通 RAG 添加检索上下文并让模型写作，留给它自由倾向于记忆知识。Perplexity 收紧规则：用 Srinivas 的话说，模型不应说出未检索到的内容，并被告知仅使用检索段落。若来源薄弱，正确输出是“我没有足够信息”。Perplexity 借用的模型是学术和维基百科写作，所有声明都需要引用显著来源，任何未引用的都视为意见。权衡是真实的，他们接受了：严格根植的引擎有时会拒绝一个聊天模型会回答的问题，因为来源未覆盖。回报是当它回答时，你可以点击脚注检查。

Decision 2: own the index instead of renting search. Renting retrieval means renting your error rate, since three of the four hallucination causes are set by whoever runs the search. So Perplexity built the crawler, the index, and the ranking stack itself. The cost is steep and standing: crawling, storing, and continuously reranking hundreds of billions of pages, then running a 70B model on specialized hardware for every answer, is a bill that has outrun the company’s revenue so far. The benefit is that retrieval quality became a knob Perplexity turns rather than one it waits on a vendor to turn⁷.决策 2：拥有索引而非租用检索。租用检索意味着租用错误率，因为四个幻觉原因中有三个由运行搜索的人决定。因此 Perplexity 建立了爬虫、索引和排名堆栈。成本高昂且持续：爬取、存储并持续重新排名数十亿页面，然后为每个答案在专用硬件上运行 70B 模型，账单已超过公司迄今为止的收入。好处是检索质量成为 Perplexity 可以调节的旋钮，而不是等待供应商调节。

Decision 3: make ranking a cheap-then-expensive cascade. Quality ranking and low latency pull against each other. Perplexity’s answer is a hybrid funnel: cheap scorers drop the obvious misses first, then the expensive cross-encoder judges only the survivors, so retrieval still lands inside the 100-millisecond budget. The catch is recall. A candidate the cheap scorers throw out never reaches the cross-encoder, so an early filter set too tight silently drops answers the reranker would have caught. Tuning that cut point is a permanent maintenance cost.决策 3：让排名成为先便宜后昂贵的级联。高质量排名和低延迟相互拉扯。Perplexity 的答案是混合漏斗：廉价评分器先去掉明显错误，然后昂贵的交叉编码器只评估幸存者，检索仍在 100 毫秒预算内。缺点是召回率。廉价评分器抛出的候选永远不会到达交叉编码器，因此过早的过滤过紧会悄悄丢失交叉编码器本可捕获的答案。调节该阈值是永久维护成本。

The Honest Take

诚实的看法

What works is the strict-grounding bet. Tying every sentence to a retrieved source is a structural fix for hallucination rather than a slogan, and it is why people reach for Perplexity on questions where being wrong has a cost. Owning retrieval compounds it, because each of the four hallucination causes becomes a knob Perplexity can turn rather than a vendor it can only email.有效的是严格根植的赌注。将每句与检索来源绑定是对幻觉的结构性修复，而非口号，这也是人们在错误成本高的提问中选择 Perplexity 的原因。拥有检索放大了它，因为四个幻觉原因中的每一个都成为 Perplexity 可以调节的旋钮，而不是只能发邮件给供应商的。

What is still unsolved is that grounding reduces hallucination, it does not end it. Srinivas says as much: the model can still misread a good passage, the index can still serve a thin one, and a citation only proves a sentence has a source; it does not prove the source is right or that the model summarized it faithfully. A footnote is a pointer, and pointers can aim at the wrong thing.尚未解决的是根植降低幻觉，但并未终止。Srinivas 也这么说：模型仍可能误读好段落，索引仍可能提供薄弱段落，引用仅证明句子有来源；并不证明来源正确或模型忠实总结。脚注是指针，指针可能指向错误的东西。

The elephant in the room is opacity. Perplexity publishes almost no hard backend numbers. We know the index is “hundreds of billions of pages” and the latency budget is “about 100 milliseconds,” but there is no public figure for queries per second, no per-stage latency breakdown, no disclosed reranker model or stage count, no named vector store. Plenty of write-ups invent that precision; this one stays with the figures Perplexity has actually published.房间里的大象是模糊性。Perplexity 几乎不公布硬件后端数字。我们知道索引是“数十亿页面”，延迟预算是“约 100 毫秒”，但没有公开每秒查询数、每阶段延迟细分、重排序模型或阶段计数、命名向量存储。许多写作会发明那种精度；这一次坚持 Perplexity 实际公布的数字。

Could a smaller team build this? The pattern, yes. Hybrid retrieval, a cross-encoder rerank stage, strict grounding, and cited generation are reachable today with Vespa or comparable open tools over a focused corpus, the path How DoorDash Built Their RAG System walked. What does not transfer is the open web. Crawling hundreds of billions of pages and continuously reranking them is a standing infrastructure commitment: a dedicated team, a crawl budget, and years of tuning that no small team can shortcut.小团队能否构建？模式是的。混合检索、交叉编码器重排序、严格根植和引用生成今天可以用 Vespa 或类似开源工具在聚焦语料库上实现，正如 How DoorDash Built Their RAG System 所走的路径。无法转移的是开放网络。爬取数十亿页面并持续重新排序是持续的基础设施承诺：专门团队、爬虫预算和多年调优，任何小团队都无法捷径。

The One Thing to Remember

要记住的一件事

The model is the smallest part of this story. Sonar is a fine-tuned 70B, the kind thousands of teams can run, and it is not what makes Perplexity hard to copy. The moat is everything wrapped around it: an owned index of hundreds of billions of pages, a rerank funnel that lands in 100 milliseconds, a planner that decomposes the hard questions, and a grounding rule strict enough that the model would rather say “I do not know” than invent. An answer engine is mostly retrieval, and the sentence generator is the last and smallest step.模型是这个故事中最小的部分。Sonar 是微调的 70B，千百个团队都能运行，它并不是 Perplexity 难以复制的原因。护城河是围绕它的一切：拥有的数十亿页面索引、在 100 毫秒内完成的重排序漏斗、拆解难题的规划器，以及足够严格的根植规则，让模型宁愿说“我不知道”也不愿编造。答案引擎主要是检索，句子生成器是最后且最小的步骤。

---

💬 Building RAG over your own corpus and deciding how hard to ground it? Tell me in the comments where your retrieval falls down. I read every one.💬 在自己的语料库上构建 RAG 并决定根植程度？在评论中告诉我你的检索在哪儿失效。我会读每一条。

---

FAQ

How does Perplexity’s search engine work?
Perplexity is a retrieval-augmented answer engine. For each question it searches its own index of hundreds of billions of pages, narrows the results through a funnel of fast lexical and embedding scorers and then cross-encoder rerankers, assembles the top passages into a prompt, and has its Sonar model write an answer with a citation on every sentence, drawing only from what was retrieved.Perplexity 的搜索引擎如何工作？Perplexity 是一个检索增强答案引擎。对于每个问题，它在自己的数十亿页面索引中搜索，使用快速词汇和嵌入评分器的漏斗以及交叉编码器重排序器缩小结果，组装顶部段落成提示，并让其 Sonar 模型写出每句都有引用的答案，仅从检索到的内容中提取。

What model does Perplexity use?
Perplexity’s default answer model is Sonar, fine-tuned from Meta’s Llama 3.3 70B for factuality and served on Cerebras hardware at about 1,200 tokens a second. It can route to other models too, but Sonar is tuned for the specific job of writing concise, cited answers from retrieved passages rather than from memory.Perplexity 使用什么模型？Perplexity 的默认答案模型是 Sonar，基于 Meta 的 Llama 3.3 70B 微调以提升事实性，并在 Cerebras 硬件上以约 1,200 tokens/秒 运行。它也可以路由到其他模型，但 Sonar 针对从检索段落写简洁、引用答案的特定工作进行了调优。

Is Perplexity just a wrapper on Google?
No. Perplexity runs its own crawler, PerplexityBot, and its own search index of hundreds of billions of pages, the same index it now sells through its Search API. It also licenses third-party crawlers, so it uses hybrid sourcing, but the index and ranking stack are its own rather than a resold Google or Bing feed.Perplexity 只是 Google 的包装器吗？不。Perplexity 运行自己的爬虫 PerplexityBot 和自己的数十亿页面搜索索引，即它现在通过搜索 API 销售的同一索引。它也授权第三方爬虫，因此使用混合来源，但索引和排名堆栈是自己的，而不是转售的 Google 或 Bing 供稿。

How does Perplexity reduce hallucinations?
Through strict grounding. The model is instructed to use nothing beyond the retrieved passages, to cite every sentence, and to say it lacks enough information when the sources fall short. Because most hallucination traces to weak retrieval, Perplexity also owns the index to keep results fresh and relevant. Grounding lowers the hallucination rate without eliminating it.Perplexity 如何减少幻觉？通过严格根植。模型被指示仅使用检索段落，引用每一句，并在来源不足时说明缺乏信息。由于大多数幻觉源于弱检索，Perplexity 还拥有索引以保持结果新鲜和相关。根植降低幻觉率，但未消除。

🔜 Tuesday: Agent Prompt Engineering, the patterns that keep an agent on task instead of improvising.🔜 周二：代理提示工程，保持代理任务而非即兴发挥的模式。

1. We Have a Package for You! A Comprehensive Analysis of Package Hallucinations by Code Generating LLMs, arXiv 2406.10279 (USENIX Security 2025)

2. Aravind Srinivas at Bloomberg Tech Summit, June 2025

3. Lex Fridman Podcast #434, Aravind Srinivas, June 2024

4. Introducing the Perplexity Search API, Perplexity, September 2025

5. Cerebras Powers Perplexity Sonar with Industry’s Fastest AI Inference, Cerebras, February 2025

6. Breakout Agents: Perplexity Pro Search, LangChain, February 2025

7. Perplexity’s 2024 revenue and costs, reported by The Information, May 2025