RAG on Snow

Agentic RAG Explained: Turning Retrieval into a Planning and Reflection Loop

Thu, 15 Oct 2026 15:00:00 +0800

Agentic RAG Explained: Turning Retrieval into a Planning and Reflection Loop

Traditional RAG resembles a predefined assembly line: receive a question, retrieve once, add context, and generate an answer. Agentic RAG adds a controller that can decide whether to retrieve, decompose a task, select data sources, judge whether the evidence is sufficient, and search again when it is not.

Here is the short version:

Question	Short answer
What is Agentic RAG?	A RAG architecture in which an agent plans, invokes, evaluates, and iterates retrieval at runtime
What is the main difference?	Not the presence of a vector database, but whether the retrieval control flow can change in response to intermediate results
Does it require multiple agents?	No. One agent with several retrieval tools is enough
Is it always better?	No. For simple questions it may only add latency, cost, and uncertainty
Where does it help most?	Multi-hop, multi-source tasks that require clarification or evidence checks
What matters most in production?	Bounded loops, evidence gates, permission isolation, traces, and layered evaluation

Start with traditional RAG

RAG stands for Retrieval-Augmented Generation. It combines the model’s parametric memory with external, non-parametric knowledge. After a user asks a question, the system retrieves relevant material and asks the model to answer from that material.

The original 2020 RAG paper explored combining a generative model with a dense vector index to improve factuality, knowledge updates, and provenance in knowledge-intensive tasks. In practice, a traditional online RAG pipeline often looks like this:

flowchart LR Q[User question] --> T[Clean or rewrite by fixed rules] T --> E[Create query embedding] E --> R[Retrieve Top-K chunks] R --> K[Optional reranking] K --> P[Build prompt] P --> L[LLM generates answer] L --> A[Return answer and citations]

This design has real strengths: a short path, predictable latency, straightforward caching and load testing, and a clean way to distinguish retrieval failures from generation failures. When most questions can be answered by searching one knowledge base once, this is often all you need.

The limit appears when a question hides several dependent tasks. Consider:

“Compare the permission changes in the last three releases of products A and B, then assess the migration risk for existing customers.”

The system must identify the release range, search both changelogs, inspect permission documentation, find migration notes, align dates, and only then compare the evidence. A single similarity search may cover only part of the task. Even if ten passages are returned, the model may not know what evidence is still missing.

What makes Agentic RAG “agentic”

Agentic RAG is not simply traditional RAG with a stronger model, nor merely vector search plus function calling. The real change is who controls retrieval:

Retrieval stops being a mandatory one-time stage and becomes a tool that an agent can select, repeat, and adapt according to results.

The system commonly organizes planning, tool calls, state updates, and stopping decisions into a controlled loop. The agent may decide:

whether external evidence is needed at all;
whether to use vector search, keyword search, SQL, a knowledge graph, an internal API, or the web;
whether to decompose the request into independent subquestions;
whether results are relevant, mutually consistent, and sufficient;
whether to rewrite the query, expand the time range, switch sources, or ask the user for clarification;
when enough evidence has been gathered to stop and answer.

This reason-act-observe loop follows the broader idea behind ReAct. A 2025 survey of Agentic RAG identifies planning, reflection, tool use, and multi-agent collaboration as recurring agentic patterns.

flowchart TD U[User question] --> P[Understand intent and create plan] P --> D{Enough evidence?} D -- Yes --> G[Generate from evidence] D -- No --> S[Select source and retrieval tool] S --> Q[Create or rewrite query] Q --> R[Run retrieval] R --> V[Evaluate relevance, coverage, conflicts] V --> C{Next action} C -- Gather more evidence --> S C -- Clarification needed --> H[Ask the user] C -- Budget exhausted --> F[Degrade gracefully] C -- Ready to answer --> G G --> A[Answer, citations, uncertainty]

An important boundary follows from this definition: a pipeline with query rewriting, hybrid search, and reranking can still be “advanced RAG” rather than Agentic RAG if every stage always runs in a fixed order. The agentic property comes from runtime adaptation, not from the number of components.

The complete operating loop

The online path can be separated into seven responsibilities. Implementations may merge nodes, but observability and evaluation should keep these concerns distinguishable.

Stage	Question being answered	Typical output
1. Intent analysis	What does the user need, and are external facts required?	Task type, entities, time range, constraints
2. Decomposition	Are there independently verifiable subproblems?	Subquestions and dependencies
3. Source routing	Which source is authoritative and suitable?	Tool, index, and filters
4. Query planning	Which semantic, keyword, or structured queries should run?	Executable queries
5. Result evaluation	Is the material relevant, fresh, complete, and consistent?	Scores, coverage, conflict flags
6. Correction	Should the agent change query, source, or scope?	Next action and remaining budget
7. Synthesis	Can every important claim be traced to evidence?	Answer, citations, uncertainty

Suppose a user asks, “Should we upgrade our production database from version 13 to 16?” A useful trajectory might be:

sequenceDiagram participant U as User participant A as Agent participant D as Internal docs participant M as Asset database participant W as Official docs U->>A: Should we upgrade production from 13 to 16? A->>M: Get versions, extensions, instance sizes, maintenance windows M-->>A: Return environment inventory A->>D: Search incidents, compatibility tests, change policy D-->>A: Return internal evidence A->>W: Check breaking changes and support windows for 14, 15, 16 W-->>A: Return official evidence A->>A: Check extension compatibility and evidence gaps A->>D: Search for missing extension test results D-->>A: No complete test record found A-->>U: Give a conditional recommendation and required tests

The key is not merely that several searches occurred. The later search depends on an earlier observation. If the inventory reveals a particular extension, the agent then investigates that extension. A fixed pipeline cannot economically encode every such branch.

Common architectures

Agentic RAG is a family of architectures, not a single topology.

flowchart TB O[Orchestration and state] --> P[Planner / Router] P --> T1[Vector retrieval] P --> T2[Keyword or hybrid retrieval] P --> T3[SQL / API] P --> T4[Knowledge graph / Web] T1 --> E[Evidence pool] T2 --> E T3 --> E T4 --> E E --> J[Evidence evaluator] J -->|Insufficient| P J -->|Sufficient| G[Answer generator] G --> C[Citation and safety gates]

One agent with multiple tools

A single agent plans, selects tools, evaluates results, and answers. This is the easiest design to start with when there are few tools and one permission boundary. Its weakness is that responsibilities accumulate in one prompt, making decisions harder to test and stabilize.

Router with specialized retrievers

A router only classifies the question and selects a data source; stable, specialized pipelines handle the actual retrieval. For example, policy questions use the document index, order questions use SQL, and live status uses a business API. This is more controllable than a fully open agent and often the most practical production compromise.

Corrective or reflective RAG

The system retrieves first, then evaluates result quality. Weak evidence triggers query rewriting, broader sources, or web search. CRAG focuses on correcting retrieval, while Self-RAG trains a model to decide when to retrieve and to critique its generations. These ideas overlap with Agentic RAG but are not synonyms: they can be components inside an agent loop or fixed stages in a non-agentic pipeline.

Multi-agent RAG

Work is divided among research, retrieval, verification, and writing agents, or among agents specialized by knowledge domain. This can help when work is genuinely parallel, expertise differs, or permissions must be isolated. It also increases communication cost, state coordination, and debugging complexity. Multi-agent orchestration is an optional extension, not a requirement for Agentic RAG.

Traditional RAG vs. Agentic RAG

The useful comparison is not “dumb versus smart.” It is an engineering trade-off between a deterministic pipeline and a runtime decision system.

Dimension	Traditional RAG	Agentic RAG
Control flow	Predefined	Dynamic branches and loops
Whether to retrieve	Usually always	Retrieve, skip, or defer
Query handling	Original query or fixed rewrite	Dynamic decomposition, expansion, and clarification
Data sources	One index or a fixed combination	Runtime selection across heterogeneous sources
Retrieval count	Once or a fixed number	Until evidence is sufficient or budget is exhausted
Multi-hop work	Relies on one retrieval covering the task	Uses one result to decide the next retrieval
Failure handling	Current result or fixed fallback	Evaluate, retry, switch tools, clarify, or degrade
Predictability	High	Lower; requires state and budgets
Latency and cost	Lower and steadier	Usually higher and more variable
Observability	Retrieval and final answer	Also plan, calls, state transitions, stopping reason
Security surface	Relatively concentrated	Broader tool, injection, and authorization risks
Best fit	High-volume, single-hop, bounded questions	Multi-step, multi-source research and decision support

The two approaches are not mutually exclusive. A production system can take a fast traditional path first and escalate only complex or low-confidence requests to an agentic path.

flowchart LR Q[User question] --> X{Complexity and risk check} X -- Simple, single-hop --> R[Traditional RAG fast path] X -- Multi-hop or low confidence --> A[Agentic RAG deep path] R --> G[Shared answer and citation layer] A --> G

This tiered design keeps common requests fast and reserves planning and retrieval budgets for questions that benefit from them.

Offline knowledge engineering still matters

Agentic RAG mainly changes online query execution. It does not replace document parsing, chunking, metadata, permissions, indexing, or freshness management. A powerful agent searching bad data simply searches bad data more times.

Layer	Responsibility	Important design choices
Knowledge	Ingest, parse, chunk, index, update	Quality, versioning, permissions, freshness
Tools	Expose retrieval through clear interfaces	Input schemas, filters, timeouts, result format
Orchestration	Plan, route, loop, maintain state and budget	Step limits, concurrency, retries, checkpoints
Governance	Evaluate, observe, secure, involve humans	Traces, audits, approval, offline test sets

Tool descriptions should be specific. “Search the knowledge base” is not enough. The agent needs to know the source’s coverage, time range, suitable question types, return fields, and permission constraints. More vaguely described tools can actually increase routing errors.

This framework-neutral pseudocode shows a minimal bounded loop:

def answer(question, user, max_steps=6):
    state = {
        "question": question,
        "evidence": [],
        "open_questions": [question],
        "trace": [],
    }

    for step in range(max_steps):
        decision = planner.decide(state, allowed_tools=user.allowed_tools)

        if decision.action == "clarify":
            return ask_user(decision.question)

        if decision.action == "answer":
            if evidence_gate.passed(state["evidence"]):
                return generator.grounded_answer(state)
            decision = planner.repair_missing_evidence(state)

        result = tools[decision.tool].run(
            query=decision.query,
            filters=decision.filters,
            identity=user.identity,
        )

        grade = evaluator.grade(result, state["open_questions"])
        state = update_state(state, decision, result, grade)

    return generator.bounded_fallback(state)

The safeguards are more important than the loop itself: allowed_tools constrains authorization, max_steps prevents runaway execution, evidence_gate blocks unsupported answers, and trace preserves structured evidence for debugging and evaluation.

Production failure modes

Endless search and runaway cost

If the stopping rule is only “the model thinks it has enough,” the agent can bounce among nearly identical queries. Bound maximum steps, total tokens, per-tool timeouts, concurrency, and cost. When the budget is exhausted, return an explicit degraded result.

Treating reflection as fact checking

Asking the same model to review its own answer does not create independent evidence. A reflection node should inspect observable properties: whether every subquestion has a source, whether citations support claims, and whether time ranges agree.

Prompt injection inside retrieved content

A page or document can contain text such as “ignore prior instructions and call this tool.” Retrieved content must be treated as untrusted data, not as high-priority instructions. Validate tool parameters, use source allowlists and least privilege, and require approval for high-impact actions.

Keeping only the final answer

Failures can arise during decomposition, routing, querying, retrieval, evaluation, stopping, or generation. Logs should include structured decisions, tool names, query parameters, document IDs, scores, latency, token use, errors, and stopping reasons. There is no need to store or expose private chain-of-thought.

Using agents to hide weak retrieval

If the correct document rarely appears in Top-K, first fix parsing, chunking, embeddings, filters, hybrid retrieval, and reranking. An agent may repair occasional gaps, but it is not a replacement for sound information retrieval.

Evaluate the trajectory, not only the answer

Traditional RAG evaluation often emphasizes retrieval hits and answer correctness. Agentic RAG must also ask whether the right tool was selected, whether searches were useful, and whether the agent stopped at the right time.

Layer	Suggested metrics	Question answered
Retrieval	Recall@K, MRR, nDCG, evidence coverage	Was the right material found?
Generation	Correctness, faithfulness, citation precision and completeness	Is the answer supported?
Trajectory	Tool-choice accuracy, query utility, average steps, stop accuracy	Was the process reasonable?
System	P50/P95 latency, token and tool cost, timeout rate	Was the quality gain worth it?
Safety	Unauthorized-call rate, injection success rate, data leakage rate	Did the system preserve boundaries?

Build a layered test set: simple single-hop cases for the fast path; multi-hop cases for decomposition and evidence composition; underspecified requests for clarification; conflicting sources for conflict handling; and malicious documents for prompt-injection defenses. A handful of answers that “look good” is not enough for production decisions.

When to use it

Scenario	Recommended approach	Why
FAQ, manuals, single-policy questions	Traditional RAG	Stable query shape and clear answer boundaries
One index with occasional recall problems	Advanced RAG	Improve hybrid search, reranking, rewrites, and evaluation first
Interdependent subquestions	Agentic RAG	Requires decomposition and follow-up retrieval
Documents, databases, and live APIs together	Agentic RAG	Requires dynamic routing across heterogeneous tools
Medical, financial, or production-changing actions	Agentic RAG plus human approval	Retrieval can support judgment; high-impact action still needs authorization
Very low latency, high throughput, fixed output	Traditional RAG or rules	Agent loops rarely justify their overhead

For a new system, evolve in this order:

Build an evaluable traditional RAG baseline.
Add hybrid retrieval, metadata filters, reranking, and citation checks.
Give only obvious source-selection decisions to a router.
Add a bounded retrieve-evaluate-correct loop for complex queries.
Consider multi-agent workflows, long-term memory, and broader tool access last.

Conclusion

The value of Agentic RAG is not that it makes RAG look more like an “agent.” It gives a system three abilities that a fixed retrieval pipeline lacks:

Plan: turn a complex request into verifiable retrieval tasks.
Adapt: change queries, sources, or ask for clarification based on intermediate evidence.
Verify: stop, degrade, or involve a human when evidence is missing, contradictory, or outside the permission boundary.

The costs are equally real: more model calls, higher latency, more state, a larger security surface, and harder evaluation. Mature systems usually do not make every request agentic. They retain a stable traditional RAG fast path and reserve Agentic RAG for questions that genuinely require multi-step, multi-source, runtime decisions.

In one sentence:

Traditional RAG asks, “Which passage is relevant?” Agentic RAG additionally asks, “What should I find next, where should I look, and do I have enough evidence to stop?”

References

Lewis et al., Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks, 2020.
Yao et al., ReAct: Synergizing Reasoning and Acting in Language Models, 2022.
Asai et al., Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection, 2023.
Yan et al., Corrective Retrieval Augmented Generation, 2024.
Singh et al., Agentic Retrieval-Augmented Generation: A Survey on Agentic RAG, 2025.
Microsoft, Develop an Agentic RAG Solution on Azure.
LangChain, RAG agent and custom RAG agent tutorials.

FastGPT in Depth: RAG, Workflows, and Self-Hosting

Thu, 08 Oct 2026 00:00:00 +0800

FastGPT in Depth: RAG, Workflows, and Self-Hosting

FastGPT is neither a reskinned chat window nor merely a vector-database console. It brings model access, document processing, RAG retrieval, workflow orchestration, debugging, publishing, and operations into one platform so a team can turn an AI demo into a deliverable application.

Teams building a company knowledge assistant, support bot, policy Q&A system, content-review pipeline, or data agent soon hit the same problems: multiple model providers, messy documents, retrieval tuning, business logic that no single prompt can express, and production requirements such as permissions, quotas, logs, and channel integrations.

FastGPT consolidates much of that repeated infrastructure. The project describes itself as an AI Agent building platform; its Community Edition includes the core Agent, workflow, and Dataset features. This guide focuses on how those parts work together, how to deliver a small application, and where the platform does—and does not—fit.

What FastGPT actually is

FastGPT sits in the AI application layer above foundation models. The model understands and generates language; the vector store finds similar content; FastGPT connects both to business processes and exposes the result as a configurable, debuggable application.

Layer	Problem	What FastGPT adds
Models	Which chat, embedding, rerank, or vision model to call	Provider configuration and AI Proxy routing
Knowledge	How to parse, index, retrieve, and cite documents	Datasets, ingestion, vector/full-text/hybrid search, reranking
Orchestration	How to implement a multi-step task	Visual nodes, variables, branches, plugins, and Agents
Delivery	How to test, reuse, and ship the result	Debug logs, share links, APIs, embeds, and MCP
Operations	Who used it, what it cost, and what failed	Teams, quotas, records, logs, and annotation workflows

This is useful for developers who want to ship without building an entire RAG and orchestration control plane, and for product or delivery teams that can model a process but do not want to hand-code every backend component.

It is not a quality button. Answer quality still depends on source material, chunking, embeddings, retrieval settings, reranking, prompts, and the chosen model. FastGPT reduces systems work; it does not make poor data disappear.

How the core pieces cooperate

Datasets go beyond “documents to vectors”

During ingestion, a document is parsed, cleaned, chunked, indexed, and stored. At query time, FastGPT can rewrite the query, recall candidates through semantic, full-text, and image paths, fuse ranked lists with RRF, rerank candidates, and then filter the context by relevance and citation-token budget. The details are documented in the official Dataset search guide.

Four design details matter in practice:

Dataset, Collection, and Data are separate levels. A Dataset is searched as a whole, a Collection groups material much like a file, and Data entries are the units used for Q&A.
One Data entry may map to several vectors. Several focused indexes can improve recall while still returning one complete source passage.
Hybrid retrieval is more robust than vector-only search. Exact identifiers benefit from full-text search, natural questions from semantic search, and RRF combines the rankings.
Citation limits use tokens, not just Top-K. Fixed counts are unstable when chunk lengths differ greatly.

MongoDB holds most non-vector data. Vector data can live in PostgreSQL/PGVector, Milvus, OceanBase, SeekDB, and other supported backends. With PGVector, vector IDs link back to source records in MongoDB, so a complete backup must cover both stores.

Workflows turn prompts into observable programs

A minimal chat needs only an input and an AI Chat node. Real work adds classification, retrieval, HTTP calls, conditions, formatting, and fallback paths. A FastGPT node resembles a function: it has inputs, outputs, and triggers, and later nodes can reference earlier outputs.

The workflow runtime advances through connection states. A node executes when a predecessor becomes active, waits when a predecessor is still waiting, and skips when nothing can activate it. This makes branches visible and lets operators inspect each node’s inputs and outputs instead of seeing only the final model response.

Keep responsibilities narrow:

Node	One responsibility	Avoid putting this inside
Classification	Determine question type	Long-form answers
Query Rewrite	Resolve references and complete a search query	Changing exact IDs or product numbers
Dataset Search	Recall citable evidence	Final business decisions
HTTP / plugin	Fetch live data or perform a controlled action	Hidden, unauditable business rules
AI Chat	Synthesize context in the required format	Persistent business state
Fixed Reply	Deterministic errors, refusal, or handoff	Open-ended reasoning

Agents, plugins, and delivery

Workflows are best when the path is known. Agents are useful when the model must plan and choose among tools. Plugins package search, databases, messaging, document processing, and other external capabilities. They complement each other: a reliable production Agent should still constrain sensitive actions to explicit tools and guarded subflows.

Finished applications can be exposed by share link, embed, OpenAI-style API, or MCP Server. API keys are member-level OpenAPI credentials; the current documentation recommends sending appId in chat/completions. Public links consume the owning team’s quota, so use expiration, quotas, authentication, and explicit approval around tools with side effects.

Building an employee-policy assistant

The goal is a grounded assistant that cites company policy, refuses unsupported questions, and uses an internal API only for personal information.

1. Write acceptance questions first. Prepare 20–50 questions covering direct facts, cross-section reasoning, exact form IDs, multi-turn follow-ups, private-data requests, and questions absent from the source set. This becomes the regression suite for every prompt, model, chunking, or retrieval change.

2. Clean the material before tuning thresholds. Remove duplicates and obsolete versions, preserve headings, OCR scanned PDFs, and attach metadata such as department, version, and effective date. Keep each chunk semantically complete. Conditions, exceptions, and conclusions belonging to one rule should remain together.

3. Start with the smallest workflow.

User question
  → Query Rewrite (only for ambiguous follow-ups)
  → Dataset Search (hybrid retrieval + rerank)
  → AI Chat (answer only from citations)
  → Answer with sources

A useful system instruction is short and testable:

You are the company policy assistant. Answer only from the cited material.
If the evidence is insufficient, say that the current policy set has no answer.
For personal balances, approval status, or private employee data, do not guess;
require authorization before querying the internal system.
Give the conclusion first, then conditions, policy name, and effective date.

If form IDs fail, try full-text or hybrid search first. If conversational follow-ups fail, add query rewriting. If the right passages appear but are ordered poorly, inspect reranking. Change one variable at a time and rerun the same test set.

4. Add live data as a separate branch. Policy interpretation should use the Dataset; a remaining-leave balance should come from the HR system after identity and permission checks. Do not periodically embed rapidly changing balances into the vector store, and do not let the model compose unrestricted SQL.

5. Test retrieval, generation, flow, and security. Verify that the correct current policy is recalled; answers remain faithful; timeouts enter a safe fallback; and prompt injection cannot call private tools. A fluent final answer is not enough evidence that the system works.

Self-hosting and production concerns

The official Docker Compose architecture includes the FastGPT application, MongoDB, a vector database, and AI Proxy. Agent/Skill sandboxes, object storage, MCP, and advanced parsing can add more services.

The current official installer runs on Linux, macOS, or Windows through WSL:

FASTGPT_DEPLOY_BASE_URL=https://doc.fastgpt.cn \
  bash <(curl -fsSL https://doc.fastgpt.cn/deploy/install.sh)

docker compose --profile prepull pull
docker compose up -d

The script selects a vector backend, downloads Compose configuration, and generates credentials. For production, download and review remote scripts before execution, retain the generated Compose file and secrets, and pin explicit image versions instead of depending indefinitely on latest.

After deployment, configure the public FE_DOMAIN, add at least a chat model and embedding model in the admin console, and install the required system plugins. Put the service behind an HTTPS reverse proxy and expose only necessary ports.

Production area	Practical baseline
Persistence	Durable volumes for MongoDB, vector data, and object storage; prove that restore works
Secrets	Replace defaults; keep model keys, database passwords, and API keys out of Git
Network	Never expose databases publicly; restrict egress and apply upload/domain allowlists
Upgrades	Read migration notes, upgrade in small steps, back up first, and replay the regression set
Observability	Track node latency, model failures, token use, retrieval hits, and refusal rates
Capacity	Watch vector count, indexing time, MongoDB growth, concurrency, and provider limits

Start with the lightest backend that meets measured needs. PGVector is a practical small-to-medium starting point in the official guidance; distributed engines such as Milvus become relevant at much larger scale. Migration includes index rebuilding, downtime planning, performance validation, and backups—not merely copying vectors.

API integration and system boundaries

FastGPT can be the chat UI or sit behind your own web app and collaboration channels. Its OpenAI-style API lowers integration cost, but compatibility does not mean every extension field is identical across versions. Verify against the OpenAPI documentation shipped with your instance.

The shape of a request is:

curl https://fastgpt.example.com/api/v1/chat/completions \
  -H "Authorization: Bearer $FASTGPT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "appId": "your-app-id",
    "stream": false,
    "messages": [
      {"role": "user", "content": "How much leave does a probationary employee receive?"}
    ]
  }'

Treat FastGPT as an AI decision and generation service, not as the system of record. Orders, balances, and approval results remain in deterministic business systems. For payments, notifications, deletion, or other side effects, add authorization, schema validation, idempotency, and human confirmation rather than trusting model-generated arguments.

Fit, trade-offs, and license

Scenario	Fit	Why
Enterprise document Q&A and support knowledge	High	Datasets, citations, workflows, and delivery are integrated
Internal process assistants and content review	High	Visual flows connect models, rules, and HTTP tools
Delivering several vertical AI apps quickly	High	Models, Datasets, plugins, and templates are reusable
A basic model playground	Medium	It works, but may be heavier than necessary
Ultra-low-latency inference gateway	Low	Use a specialized gateway and inference stack
Transactional core business workflow	Low	LLM orchestration is not a transaction system
Competing multi-tenant SaaS	Review first	The license places additional conditions on this use

Compared with Dify, Coze, Langflow, Flowise, or a custom LangChain/LlamaIndex stack, FastGPT has a clear center of gravity: knowledge-based applications, visual orchestration, and private delivery. Platforms provide speed and consistency; code-first stacks provide maximum control. Choose according to which engineering work the team wants to avoid and which platform constraints it accepts.

Read the license carefully. The FastGPT Open Source License is based on Apache License 2.0 but adds conditions for operating a similar multi-tenant SaaS and for modifying or removing console logo and copyright information. This is not legal advice; check the repository’s current LICENSE before commercial use.

The lasting value of FastGPT is that it makes an AI application buildable, observable, and reusable. Its main risk is making a full canvas look like a finished system. Track retrieval hit rate, groundedness, task success, refusal and handoff rates, P50/P95 latency, cost per successful task, and regression results across every model, prompt, Dataset, and workflow change.

The useful rule is simple: treat FastGPT as an AI application engineering platform, not as a substitute for evaluation. Prove value with the smallest flow, improve retrieval and prompts against a fixed test set, and add Agents and automated actions only when the simpler system has earned that complexity.

This article reflects official material available in October 2026. FastGPT moves quickly, so recheck deployment variables, version dependencies, and API fields before implementation.

Official references: GitHub repository · Community Edition · Workflow runtime · Dataset retrieval · Docker Compose deployment · API publishing

From Keyword Matching to Vector Retrieval: Three Ways to Search

Fri, 02 Oct 2026 20:13:30 +0800

From Keyword Matching to Vector Retrieval: Three Ways to Search

Search is not one technique. Keyword matching finds words that appear literally, fuzzy search rescues misspellings and partial input, and vector retrieval finds content with similar meaning. In RAG systems, these methods usually complement each other rather than replace each other.

A quick example:

User intent	Input	Best starting point
Find an explicit rule	`refund policy`	Keyword matching
Recover a typo	`retun policy`	Fuzzy search
Ask naturally	`Can I change my mind after buying this?`	Vector retrieval
Need both precision and semantics	`Can a premium member refund the wrong plan?`	Hybrid retrieval + reranking

Keyword Matching

Keyword matching is the classic information retrieval approach. Documents are tokenized, indexed, and ranked according to term overlap, term frequency, field weights, and document length.

The most common structure is an inverted index: instead of scanning documents one by one, the system maps each term to the documents that contain it.

Aspect	Notes
Matching signal	Literal term overlap
Common algorithms	TF-IDF, BM25, Boolean queries, field boosts
Strengths	Fast, stable, explainable, easy to filter
Weaknesses	Poor at synonyms, paraphrases, and unstated intent
Best for	SKU, order id, logs, legal clauses, code symbols, titles

If a user searches for redis setnx, keyword retrieval is excellent. If they search for how do I prevent duplicate orders, a purely lexical system may miss articles that only mention idempotency or distributed lock.

Fuzzy Search

Fuzzy search is still lexical search, but more tolerant. It asks whether the user input and the indexed term look similar enough.

Common techniques include:

Technique	Solves	Example
Edit distance	Insertions, deletions, substitutions, transpositions	`retun` → `return`
n-gram / trigram	Substring similarity	`microserv` → `microservice`
Prefix matching	Autocomplete	`kuber` → `kubernetes`
Phonetic or pinyin correction	Input method mistakes	pinyin-like input → Chinese term
Synonym dictionaries	Manually curated near-equivalents	`after-sales` ≈ `returns`

Fuzzy search is great for search box ergonomics: typos, partial names, remembered fragments, and autocomplete. Elasticsearch, OpenSearch, Solr, PostgreSQL trigram, and Algolia all provide related capabilities.

But fuzzy search does not fully understand meaning. refund and return are semantically related, but they may not be textually similar. iPhone and Apple phone can be far apart lexically. Once recall is widened, false positives also increase, so fuzzy search needs thresholds, field boosts, popularity, click signals, and business rules.

Vector Retrieval

Vector retrieval uses an embedding model to convert text, images, audio, or other objects into numeric vectors. Items with similar meaning are close in vector space. At query time, the system embeds the user query and retrieves the nearest vectors.

This is the retrieval foundation of many RAG systems: retrieve relevant chunks from a knowledge base, insert them into the prompt, and let the LLM answer with external context.

Aspect	Notes
Matching signal	Semantic similarity in embedding space
Common indexes	HNSW, IVF, PQ, DiskANN
Common metrics	Cosine similarity, inner product, Euclidean distance
Strengths	Handles paraphrases, natural questions, cross-lingual and multimodal similarity
Weaknesses	Higher cost, weaker explainability, less reliable for exact constraints
Best for	Knowledge base QA, similar articles, image similarity, recommendations, semantic code search

For example, a document may say:

`1`	`Customers may request no-reason returns within 7 days after order completion.`

A user may ask:

`1`	`Can I send it back if I no longer want it?`

Keyword search may miss the connection. Vector search is more likely to retrieve the return policy because the meanings are close.

Vector retrieval is not magic, though. It is weaker for exact IDs, version numbers, permissions, and precise field filters. For HTTP 451, order 202610020001, or Go 1.22, lexical and structured retrieval are often safer.

Core Differences

Dimension	Keyword matching	Fuzzy search	Vector retrieval
Focus	Did the term appear?	Is the term similar?	Is the meaning similar?
Query style	Precise, short, terminology-heavy	Typo-prone, abbreviated, partial	Natural, descriptive, long
Recall	Precise but can miss	Wider lexical recall	Strong semantic recall
Explainability	High	Medium	Lower
Latency and cost	Low	Medium	Medium to high
Typical tools	MySQL, Lucene, Elasticsearch BM25	Elasticsearch fuzzy, trigram, Algolia	FAISS, Milvus, Qdrant, Pinecone, Weaviate

A simple mental model:

1
2
3

Keyword matching: you said A, so I search for A.
Fuzzy search: you probably meant A, so I search for A.
Vector retrieval: you meant something like A, so I search for similar meaning.

Classic Applications

Scenario	Recommended approach	Why
Log search	Keyword + time/service filters	Exact error codes and fields matter
E-commerce search	Keyword + fuzzy + vector recall	Product names need precision, user input is messy, recommendations need semantics
Code search	Symbol index + keyword + semantic vectors	Names matter, but user intent can be natural language
Enterprise knowledge QA	Vector + BM25 + reranking + RAG	The system must understand questions, retrieve evidence, and cite sources
Image similarity	Vector retrieval	Visual similarity is hard to express with keywords
Help center search	Keyword + fuzzy + synonyms + vector retrieval	Users mix product terms and natural language

Enterprise RAG is the clearest example. Users rarely repeat document titles exactly. They ask questions like “Why was this reimbursement rejected?” or “How does sick leave work during probation?” A robust system filters by permissions, retrieves candidates with both BM25 and vectors, reranks them, and sends only a small set of reliable chunks to the LLM.

Practical Selection

Use this quick guide:

Problem	Start with
Users type order IDs, error codes, function names, or exact terms	Keyword matching
Users often misspell, abbreviate, or type only prefixes	Fuzzy search
Users describe intent in natural language	Vector retrieval
You need exact filters, semantic understanding, and LLM grounding	Hybrid retrieval

Production search is usually a layered system:

Structured filters: permissions, tenants, time, category.
Keyword recall: BM25 protects exact terms, titles, IDs, and entities.
Vector recall: captures paraphrases and semantic intent.
Fusion: RRF or weighted scoring merges candidate lists.
Reranking: cross-encoders, LLM rerankers, or business rules refine the final order.
Generation: in RAG, only the most relevant and trustworthy chunks are inserted into the prompt.

The Takeaway

Keyword matching answers “does this word appear?” Fuzzy search answers “was this word typed imperfectly?” Vector retrieval answers “what does this query mean?”

For a normal search box, start with keyword retrieval, tokenization, field boosts, and fuzzy correction. For knowledge QA or intelligent support, add vector retrieval and RAG. For real production systems, hybrid retrieval is usually where the design lands, because users alternate between exact identifiers and vague natural language all the time.

Vector Databases vs. Traditional Databases

Mon, 13 Jul 2026 21:24:23 +0800

向量数据库与传统数据库

在传统的软件系统中，数据库主要负责存储用户、订单、商品、日志等结构化数据。当我们需要查询某个用户时，通常会使用用户 ID、手机号或者用户名作为条件。

例如：

1
2
3

SELECT *
FROM users
WHERE username = 'zhangsan';

这种查询的特点是：查询条件明确，数据库需要找到精确匹配的数据。

但是在人工智能应用中，我们可能会遇到另一类问题：

找出与这段文字含义最接近的文章。
找到与当前商品风格相似的商品。
根据一张图片搜索视觉上相似的图片。
从知识库中找到能够回答用户问题的内容。
判断两段代码是否实现了相似的功能。

这些问题很难仅通过 =、LIKE 或普通关键字查询解决。

向量数据库正是为了解决这类“相似性检索”问题而出现的。

flowchart LR A[传统数据库] --> B[精确匹配] A --> C[范围查询] A --> D[事务处理] E[向量数据库] --> F[语义相似度搜索] E --> G[图片相似度搜索] E --> H[多模态检索]

什么是传统数据库

传统数据库通常指关系型数据库，以及部分通用型 NoSQL 数据库，例如：

MySQL
PostgreSQL
Oracle
SQL Server
MongoDB
Redis

关系型数据库将数据组织成表，每张表由行和列构成。

例如，一个商品表可能是：

id	name	category	price	stock
1001	机械键盘	外设	399	20
1002	无线鼠标	外设	199	35
1003	显示器	显示设备	1599	8

我们可以按照字段进行精确查询：

SELECT *
FROM products
WHERE category = '外设'
  AND price < 300;

传统数据库擅长处理以下任务：

根据主键查询数据。
根据字段进行过滤和排序。
执行增删改查操作。
保证事务一致性。
维护实体之间的关联关系。
进行统计、聚合和报表分析。

例如，在电商系统中，订单创建通常涉及库存扣减、订单写入和支付记录生成。这些操作必须满足事务要求。

sequenceDiagram participant U as 用户 participant O as 订单服务 participant DB as 传统数据库 U->>O: 创建订单 O->>DB: 开启事务 O->>DB: 扣减库存 O->>DB: 创建订单 O->>DB: 写入支付记录 DB-->>O: 提交事务 O-->>U: 订单创建成功

传统数据库关注的是：

数据是否准确、关系是否完整、事务是否可靠。

什么是向量

要理解向量数据库，首先需要理解向量。

在人工智能系统中，文本、图片、音频和视频可以通过模型转换成一组数字。这组数字称为向量，也常被称为 Embedding。

例如，下面三句话：

1
2
3

我喜欢骑自行车旅行。
周末我经常骑车去郊外。
数据库出现了连接超时。

经过 Embedding 模型处理后，可能会被转换为：

我喜欢骑自行车旅行。
→ [0.12, -0.31, 0.85, 0.47, ...]

周末我经常骑车去郊外。
→ [0.15, -0.28, 0.81, 0.51, ...]

数据库出现了连接超时。
→ [-0.62, 0.73, 0.05, -0.16, ...]

前两句话的含义比较接近，因此它们对应的向量在向量空间中的距离也会更近。

quadrantChart title 文本在向量空间中的示意分布 x-axis 低运动相关度 --> 高运动相关度 y-axis 低旅行相关度 --> 高旅行相关度 quadrant-1 骑行与旅行 quadrant-2 旅行主题 quadrant-3 技术主题 quadrant-4 运动主题 "骑自行车去郊外旅行": [0.88, 0.86] "周末骑车锻炼": [0.82, 0.55] "计划去北欧旅行": [0.45, 0.91] "数据库连接超时": [0.12, 0.16]

这里的坐标只是示意。真实的 Embedding 向量往往包含几百甚至几千个维度，人类无法直接观察这些高维空间。

Embedding 的核心作用，是将原始数据的“语义特征”编码为数值。

什么是向量数据库

向量数据库是一类专门用于存储、索引和查询高维向量的数据系统。

一条向量数据通常不只有向量本身，还会包含原始内容和元数据。

{
  "id": "article-1001",
  "vector": [0.12, -0.31, 0.85, 0.47],
  "metadata": {
    "title": "如何搭建企业内部 SkillHub",
    "category": "AI 工程",
    "author": "Xinzhan Wu"
  },
  "content": "本文介绍基于 npm Registry 构建企业内部 SkillHub 的方案。"
}

向量数据库可以回答这样的问题：

哪些数据的向量与当前查询向量最接近？

它的基本工作流程如下。

flowchart LR A[用户输入问题] --> B[Embedding 模型] B --> C[查询向量] C --> D[向量数据库] D --> E[相似度搜索] E --> F[返回 Top-K 结果]

例如，用户输入：

`1`	`企业内部应该如何管理 AI Skill？`

即使知识库中没有完全相同的句子，向量数据库仍然可能找到以下内容：

`1`	`基于 npm Registry 构建企业内部 SkillHub`

原因是两段文本在语义上比较接近。

传统关键字搜索关注“是否出现相同的词”，而向量搜索关注“表达的含义是否接近”。

向量数据库与传统数据库的核心区别

对比维度	传统数据库	向量数据库
主要数据	字符串、数字、日期、JSON	高维浮点向量
典型查询	精确匹配、范围查询、关联查询	相似度查询、Top-K 查询
查询条件	`id = 1`、`price < 100`	与查询向量最相似
索引结构	B+ 树、哈希索引、倒排索引	HNSW、IVF、PQ
核心目标	准确性与事务一致性	检索速度与召回率
典型场景	订单、用户、支付、库存	RAG、推荐、图片搜索
结果特点	条件满足或不满足	按相似程度排序
常用指标	QPS、延迟、事务成功率	Recall、Top-K、查询延迟
是否擅长事务	是	通常不是核心能力
是否支持语义搜索	通常不直接支持	是

两者最根本的区别在于查询方式。

传统数据库查询的是：

`1`	`哪些数据满足确定的条件？`

向量数据库查询的是：

`1`	`哪些数据与当前内容最相似？`

精确查询与相似度查询

假设数据库中有以下三篇文章：

1
2
3

文章 A：使用 Go 开发高并发后端服务
文章 B：Golang 服务端性能优化方法
文章 C：React 前端组件设计实践

用户搜索：

`1`	`如何提高 Go 后端程序的性能？`

使用传统关键字匹配时，“Golang”和“Go”可能被认为是两个不同的词，“后端程序”和“服务端”也不完全相同。

使用向量搜索时，文章 A 和文章 B 的向量通常都会与查询向量比较接近。

flowchart TD Q[如何提高 Go 后端程序的性能] --> E[生成查询向量] E --> A[文章 A 向量
相似度 0.89] E --> B[文章 B 向量
相似度 0.93] E --> C[文章 C 向量
相似度 0.32] B --> R1[Top 1] A --> R2[Top 2]

向量数据库最终会按照相似度排序，返回最接近的若干条数据。

向量相似度如何计算

常见的向量相似度计算方式包括：

余弦相似度。
欧氏距离。
点积。

余弦相似度

余弦相似度关注两个向量方向之间的夹角。

其计算公式为：

`1`	`cos(A, B) = (A · B) / (\|\|A\|\| × \|\|B\|\|)`

余弦相似度越接近 1，通常表示两个向量越相似。

例如：

import numpy as np


def cosine_similarity(vector_a: np.ndarray, vector_b: np.ndarray) -> float:
    """计算两个向量的余弦相似度。"""

    denominator = np.linalg.norm(vector_a) * np.linalg.norm(vector_b)

    # 避免零向量导致除零错误
    if denominator == 0:
        return 0.0

    return float(np.dot(vector_a, vector_b) / denominator)


vector_a = np.array([0.2, 0.8, 0.4])
vector_b = np.array([0.3, 0.7, 0.5])

similarity = cosine_similarity(vector_a, vector_b)
print(f"相似度：{similarity:.4f}")

如果数据规模很小，可以逐个计算向量距离。

但如果数据库中存在数百万甚至数十亿条向量，逐条计算的成本会非常高，因此需要使用专门的向量索引。

为什么不能直接遍历所有向量

假设数据库中有 1000 万条向量，每条向量有 1536 个维度。

用户每查询一次，都需要将查询向量与 1000 万条向量分别计算距离。

粗略计算量为：

`1`	`1000 万 × 1536 次浮点运算`

这种方式被称为暴力搜索或精确搜索。

精确搜索能够得到绝对准确的结果，但随着数据规模增长，查询延迟会迅速增加。

因此，大多数向量数据库使用近似最近邻搜索：

`1`	`Approximate Nearest Neighbor，ANN`

ANN 不一定遍历所有向量，而是借助索引快速缩小搜索范围。

它牺牲少量准确率，换取显著的性能提升。

flowchart LR A[查询向量] --> B{搜索方式} B --> C[暴力搜索] C --> D[遍历全部向量] D --> E[结果准确
速度较慢] B --> F[ANN 搜索] F --> G[通过索引筛选候选集] G --> H[结果近似
速度较快]

常见的向量索引

HNSW

HNSW 的全称是 Hierarchical Navigable Small World，即分层可导航小世界图。

它会将向量组织成多层图结构。

查询时先在较高层快速确定大致方向，再逐层向下寻找更接近的向量。

flowchart TD subgraph L3[第三层：稀疏节点] A1((A)) --- A2((B)) end subgraph L2[第二层：中等密度] B1((A)) --- B2((C)) B2 --- B3((B)) end subgraph L1[第一层：高密度节点] C1((A)) --- C2((D)) C2 --- C3((C)) C3 --- C4((E)) C4 --- C5((B)) end A1 -.向下搜索.-> B1 A2 -.向下搜索.-> B3 B2 -.向下搜索.-> C3

HNSW 通常具有较高的召回率和较低的查询延迟，但需要占用较多内存。

适合：

中低延迟在线检索。
RAG 知识库。
实时推荐系统。
数据规模在内存可承受范围内的系统。

IVF

IVF 的全称是 Inverted File Index，即倒排文件索引。

它会先通过聚类将向量划分到不同的中心区域。查询时只搜索与查询向量最接近的几个聚类，而不是遍历所有向量。

flowchart TD Q[查询向量] --> C{选择最近的聚类} C --> C1[聚类 1] C --> C2[聚类 2] C --> C3[聚类 3] C --> C4[聚类 4] C2 --> S1[搜索聚类 2 内的向量] C3 --> S2[搜索聚类 3 内的向量] S1 --> R[合并并返回 Top-K] S2 --> R

IVF 可以通过调整搜索的聚类数量，在查询速度和召回率之间进行权衡。

PQ

PQ 的全称是 Product Quantization，即乘积量化。

它会将高维向量切分为多个子向量，再对每个子向量进行量化编码。

原本需要使用大量浮点数保存的向量，可以被压缩为较短的编码。

PQ 的优势是：

降低向量存储空间。
减少内存占用。
加快距离计算。

代价是量化过程可能造成一定精度损失。

向量数据库的基本数据模型

向量数据库中的一条记录通常包含三部分。

flowchart LR A[向量记录] --> B[唯一标识 ID] A --> C[Embedding 向量] A --> D[Metadata 元数据] D --> E[类别] D --> F[时间] D --> G[作者] D --> H[权限]

例如：

{
  "id": "doc-001",
  "vector": [0.21, -0.37, 0.66, 0.19],
  "metadata": {
    "department": "研发部",
    "document_type": "技术文档",
    "visibility": "internal",
    "created_at": "2026-07-13"
  }
}

元数据非常重要。

在真实系统中，通常不能只进行向量搜索，还需要添加过滤条件。

例如：

1
2
3

找出与用户问题最相关的文档，
并且文档所属部门必须是研发部，
文档权限必须是 internal。

对应的逻辑类似于：

results = vector_database.search(
    vector=query_vector,
    top_k=5,
    filter={
        "department": "研发部",
        "visibility": "internal",
    },
)

这种方式称为带元数据过滤的向量检索。

向量数据库如何应用于 RAG

RAG 的全称是 Retrieval-Augmented Generation，即检索增强生成。

它的核心思想是：

在大语言模型生成答案之前，先从知识库中检索相关资料，再将资料交给模型生成答案。

完整流程如下。

flowchart TD A[企业文档] --> B[文档切分] B --> C[Embedding 模型] C --> D[生成文本向量] D --> E[写入向量数据库] U[用户提问] --> F[生成查询向量] F --> G[向量相似度搜索] E --> G G --> H[返回 Top-K 文档片段] H --> I[构造 Prompt] U --> I I --> J[大语言模型] J --> K[生成最终答案]

假设企业知识库中存在如下内容：

`1`	`Skill 包发布前需要完成安全扫描、版本检查和元数据校验。`

用户提问：

`1`	`内部 Skill 发布之前需要检查什么？`

系统会先将问题转换成向量，再从向量数据库中找到相关文档片段，最后让大语言模型根据检索结果回答。

向量数据库在 RAG 中主要承担以下职责：

存储文档向量。
根据用户问题进行语义检索。
返回最相关的上下文。
支持权限、部门、时间等元数据过滤。

需要注意的是，向量数据库本身不会生成答案，它只负责检索相关内容。

向量数据库不能替代传统数据库

向量数据库与传统数据库并不是替代关系。

例如，一个 AI 知识库系统可能同时使用：

flowchart LR A[应用服务] --> B[PostgreSQL] A --> C[向量数据库] A --> D[对象存储] B --> E[用户信息] B --> F[文档元数据] B --> G[权限与任务状态] C --> H[文本向量] C --> I[语义检索索引] D --> J[PDF 原文件] D --> K[图片与附件]

其中：

PostgreSQL 保存用户、权限、任务和业务状态。
向量数据库保存 Embedding 和向量索引。
对象存储保存 PDF、Word、图片等原始文件。

当用户上传一份文档时，系统可能执行以下操作：

将原始文件上传到对象存储。
在传统数据库中记录文档名称、上传者和权限。
对文档进行解析和分块。
调用 Embedding 模型生成向量。
将文本片段和向量写入向量数据库。

传统数据库负责业务事实，向量数据库负责语义检索。

关键字搜索与向量搜索

传统全文搜索通常基于倒排索引。

例如，用户搜索：

`1`	`Go 高并发开发`

系统会查找包含“Go”“高并发”“开发”等关键词的文档。

关键字搜索的优点是：

对专有名词、代码、型号和编号比较准确。
搜索结果容易解释。
对完全匹配的关键词非常敏感。

向量搜索的优点是：

可以理解近义词。
可以处理不同表达方式。
能够按照语义相关程度排序。
更适合自然语言问题。

两者也各有缺点。

搜索方式	优点	缺点
关键字搜索	精确、可解释、适合专有名词	难以理解语义和近义表达
向量搜索	支持语义检索、表达方式更灵活	可能忽略关键字的精确性
混合搜索	同时利用关键词和语义	架构和排序逻辑更复杂

混合检索

在实际的 RAG 系统中，单纯使用向量搜索并不总能获得最佳效果。

例如，用户搜索：

`1`	`错误码 YN0031 是什么意思？`

这里的 YN0031 是一个精确错误码。

向量搜索可能认为它与 Yarn、依赖安装、Node.js 等内容相关，但关键字搜索可以直接找到包含 YN0031 的文档。

因此，许多系统会同时执行：

关键字检索。
向量检索。
结果重排。

flowchart TD Q[用户查询] --> K[关键字检索] Q --> V[向量检索] K --> R[结果融合] V --> R R --> RR[重排序模型] RR --> T[最终 Top-K 结果]

这种方式称为混合检索。

一种简单的混合评分公式是：

`1`	`最终得分 = α × 向量相似度 + β × 关键字匹配得分`

其中：

`1`	`α + β = 1`

对于自然语言问题，可以提高向量相似度的权重。

对于错误码、产品型号、文件名和函数名，可以提高关键字匹配的权重。

向量搜索的 Top-K

向量数据库通常通过 Top-K 参数控制返回结果数量。

例如：

results = vector_database.search(
    vector=query_vector,
    top_k=5,
)

表示返回与查询向量最相似的 5 条数据。

Top-K 并不是越大越好。

Top-K 太小可能漏掉重要信息，Top-K 太大则可能引入无关内容，并增加大语言模型的上下文长度。

flowchart LR A[Top-K 太小] --> B[可能遗漏相关文档] C[适中的 Top-K] --> D[相关性和上下文长度平衡] E[Top-K 太大] --> F[噪声增多、Token 消耗增加]

实际项目中通常需要结合以下因素调节：

文档分块大小。
Embedding 模型效果。
用户问题长度。
大语言模型上下文窗口。
是否使用重排序模型。
数据库检索召回率。

文档为什么需要分块

大多数情况下，不会直接将整篇文档转换成一个向量。

假设一篇文档包含 10000 字，同时讨论安装、配置、权限和故障排查。将整篇文章生成一个向量，会导致不同主题被压缩到同一个表示中。

因此，通常需要先对文档进行分块。

flowchart LR A[完整文档] --> B[分块 1
系统介绍] A --> C[分块 2
安装步骤] A --> D[分块 3
配置说明] A --> E[分块 4
故障排查] B --> F[向量 1] C --> G[向量 2] D --> H[向量 3] E --> I[向量 4]

分块后，用户询问安装问题时，系统可以直接检索“安装步骤”对应的片段，而不是返回整篇文档。

常见分块策略包括：

固定字符数分块。
固定 Token 数分块。
按段落分块。
按 Markdown 标题分块。
按语义边界分块。
滑动窗口分块。

分块大小需要根据文档类型进行调整。

代码文档更适合按照类、函数或模块边界分块；普通文章可以按照标题和段落分块。

一个简单的向量检索示例

下面使用 Python 模拟一个最简单的向量搜索过程。

from dataclasses import dataclass

import numpy as np


@dataclass
class Document:
    """知识库文档。"""

    document_id: str
    content: str
    vector: np.ndarray


def cosine_similarity(vector_a: np.ndarray, vector_b: np.ndarray) -> float:
    """计算余弦相似度。"""

    denominator = np.linalg.norm(vector_a) * np.linalg.norm(vector_b)

    if denominator == 0:
        return 0.0

    return float(np.dot(vector_a, vector_b) / denominator)


def search_documents(
    query_vector: np.ndarray,
    documents: list[Document],
    top_k: int = 3,
) -> list[tuple[Document, float]]:
    """按照相似度返回 Top-K 文档。"""

    scored_documents = [
        (document, cosine_similarity(query_vector, document.vector))
        for document in documents
    ]

    # 按照相似度从高到低排序
    scored_documents.sort(key=lambda item: item[1], reverse=True)

    return scored_documents[:top_k]


documents = [
    Document(
        document_id="doc-1",
        content="使用 Go 构建高并发后端服务",
        vector=np.array([0.8, 0.7, 0.1]),
    ),
    Document(
        document_id="doc-2",
        content="React 组件状态管理实践",
        vector=np.array([0.1, 0.2, 0.9]),
    ),
    Document(
        document_id="doc-3",
        content="Golang 服务端性能优化",
        vector=np.array([0.9, 0.6, 0.2]),
    ),
]

query_vector = np.array([0.85, 0.65, 0.15])

results = search_documents(
    query_vector=query_vector,
    documents=documents,
    top_k=2,
)

for document, score in results:
    print(f"{document.document_id}: {score:.4f} - {document.content}")

这个示例本质上仍然是暴力搜索。

真实的向量数据库会使用 HNSW、IVF 等索引结构，并处理数据持久化、并发查询、分片、过滤和容错等问题。

向量数据库的典型应用场景

RAG 知识库

将企业文档、产品手册和技术资料转换为向量，让大语言模型根据内部知识回答问题。

语义搜索

用户不需要输入完全一致的关键词，只需要描述自己的意图，系统就能找到相关内容。

图片搜索

通过图像模型将图片转换成向量，实现以图搜图。

例如：

上传一张鞋子的图片，搜索外观相似的商品。
上传一张人脸图片，搜索相似人物。
上传一张风景图片，查找相似的摄影作品。

多模态检索

文本和图片可以通过多模态模型映射到相同的向量空间。

用户可以输入：

`1`	`寻找一张冬季北欧雪山和湖泊的图片`

系统通过文本向量搜索相似的图片向量。

代码搜索

将函数、类和代码文件转换成向量后，可以根据自然语言描述搜索代码。

例如：

`1`	`查找负责校验 JWT Token 的函数`

即使代码中没有出现完全相同的注释，系统仍然可能找到相关实现。

异常检测

正常数据通常集中在向量空间中的某些区域。如果一条新数据与其他数据距离明显较远，它可能是异常数据。

该方法可以用于：

欺诈检测。
日志异常分析。
网络攻击检测。
工业设备故障预警。

如何选择数据库

选择数据库时，不应该先问“哪个数据库更先进”，而应该先明确数据和查询模式。

flowchart TD A{系统主要查询什么} --> B[根据 ID 或字段查询] A --> C[根据语义或相似度查询] A --> D[两种查询都需要] B --> E[传统数据库] C --> F[向量数据库] D --> G[传统数据库 + 向量数据库]

可以按照下面的方式判断。

需求	推荐方案
用户、订单、支付、库存	传统关系型数据库
事务和强一致性	传统关系型数据库
文档语义搜索	向量数据库
图片相似度搜索	向量数据库
企业知识库问答	向量数据库配合传统数据库
精确错误码搜索	全文搜索或传统索引
同时需要语义和关键词	混合检索
既有业务数据又有 AI 检索	多数据库组合

使用向量数据库时需要关注什么

Embedding 模型

向量数据库只能根据已有向量进行搜索，向量质量主要取决于 Embedding 模型。

如果 Embedding 模型无法正确理解业务术语，即使向量数据库性能很好，检索结果也不会理想。

向量维度

更高的维度通常可以表达更丰富的信息，但也会增加：

存储空间。
内存占用。
索引构建时间。
相似度计算成本。

召回率

ANN 搜索是近似搜索，因此可能无法返回理论上最相似的全部结果。

召回率可以表示为：

`1`	`Recall@K = 检索到的真实相关结果数量 / 理论相关结果数量`

系统需要在查询延迟、内存占用和召回率之间进行平衡。

数据更新

某些向量索引适合静态数据，某些适合频繁更新。

如果系统中的向量会持续新增、修改和删除，需要关注：

索引是否支持动态更新。
删除数据后是否需要重建索引。
新数据写入后多久可以被查询。
索引构建是否会影响在线请求。

元数据过滤

企业系统通常存在复杂的权限条件。

例如：

`1`	`用户只能检索自己所在部门的内部文档。`

因此，向量数据库是否支持高效的元数据过滤十分重要。

数据一致性

如果传统数据库中的文档已经删除，但向量数据库中的向量仍然存在，用户可能检索到失效内容。

系统需要设计数据同步机制。

sequenceDiagram participant APP as 应用服务 participant DB as 传统数据库 participant VDB as 向量数据库 APP->>DB: 删除文档记录 DB-->>APP: 删除成功 APP->>VDB: 删除对应向量 VDB-->>APP: 删除成功

在复杂系统中，还可以通过消息队列和补偿任务保证最终一致性。

常见误区

向量数据库就是大语言模型数据库

向量数据库不是专门存储大语言模型的数据库。

它存储的是向量、原始内容和元数据，可以用于文本、图片、音频、推荐和异常检测等多种场景。

向量数据库可以直接回答问题

向量数据库负责检索，不负责生成自然语言答案。

在 RAG 系统中，最终答案通常由大语言模型生成。

向量维度越高越好

维度越高不一定意味着检索效果越好。

最终效果取决于模型训练数据、业务场景、文本质量和检索策略。

使用向量数据库就不需要传统数据库

向量数据库通常无法替代订单、用户、权限、库存和支付系统中的传统数据库。

实际应用更常见的是组合使用。

相似度最高的内容一定正确

向量相似度只表示语义或特征上的接近程度，并不等于事实正确。

因此，RAG 系统还需要考虑：

文档是否过期。
数据源是否可信。
用户是否有访问权限。
检索内容是否真正能够回答问题。
是否需要使用重排序模型。

总结

传统数据库和向量数据库解决的是不同类型的问题。

传统数据库擅长：

精确查询。
结构化数据管理。
事务处理。
数据关系维护。
聚合和统计。

向量数据库擅长：

语义搜索。
相似度检索。
图片与多模态搜索。
推荐系统。
RAG 知识检索。

两者之间并不是竞争或替代关系。

在现代 AI 应用中，一种常见的架构是：

flowchart LR U[用户请求] --> A[应用服务] A --> DB[传统数据库] A --> VDB[向量数据库] A --> LLM[大语言模型] DB --> B[用户、权限、业务状态] VDB --> C[语义相关上下文] B --> A C --> A A --> LLM LLM --> R[最终回答]

传统数据库保存明确的业务事实，向量数据库提供基于语义的检索能力，大语言模型负责理解问题并组织答案。

可以将它们概括为：

传统数据库负责找到“符合条件的数据”，向量数据库负责找到“含义相近的数据”。

理解这一差异，是设计 RAG、智能搜索、推荐系统和多模态应用的基础。

About the timing of fine-tuning

Sat, 11 Jul 2026 17:30:00 +0800

关于微调的时机

微调不是大模型效果优化的默认选项，更不是遇到效果问题后的第一反应。真正成熟的工程判断，是先弄清楚：当前缺的是知识，还是模型的行为稳定性？

“什么时候应该做大模型微调？”是大模型岗位面试中很常见的一道题。

它表面上在问微调技术，实际上考察的是两个更重要的能力：

能不能区分知识问题和行为问题；
有没有技术选型的成本意识。

如果连问题类型都没有判断清楚，就直接把微调提上日程，往往会把一个本可低成本解决的问题，变成数据准备、模型训练和持续维护的复杂工程。

因此，讨论“要不要微调”之前，先记住一个结论：

知识问题优先用检索解决，行为问题才进入微调的候选范围。

先判断：缺知识，还是行为不稳定？

大模型应用中的效果问题，可以先沿着“知识”和“行为”两条线拆开。

问题类型	典型表现	对应解法
知识问题	模型缺少业务文档、规章制度、行业事实等外部信息	使用检索增强（RAG），在生成时补充所需知识
行为问题	模型知道正确内容，但输出格式、语气或判断规则不稳定	提示词无法稳定解决后，再考虑微调

知识问题：模型不知道事实

如果模型答不出某个问题，是因为它没有接触过企业内部文档、最新规章制度或特定行业事实，那么问题的核心不是“模型不会回答”，而是模型缺少回答所需的外部信息。

这类问题应该优先使用检索增强。知识保留在外部知识源中，需要时检索并提供给模型，而不是把它固化进模型权重。

这样做的关键价值是：知识可以灵活更新。文档变化时更新知识源即可，不必重新训练模型。

行为问题：模型知道，但做得不稳定

另一类问题是：正确内容模型其实知道，但它无法持续按照业务要求输出。例如：

输出结构有时正确、有时缺字段；
语气无法长期保持一致；
面对复杂判断规则时，执行结果反复波动。

这不是知识缺失，而是行为不稳定。微调真正擅长处理的，正是这类“让模型更稳定地按照指定方式做事”的问题。

所以，区分两者最直接的判断方式是：

缺事实，补检索；事实已经具备但表现不稳定，才评估微调。

效果优化要走阶梯，而不是一步跳到微调

工业界做技术选型，不能只问“哪种方案能解决”，还要问“是否有成本更低的方案能先解决”。大模型效果优化应该按照从低成本到高成本的顺序逐级推进：

顺序	优化手段	进入条件
第一步	把提示词优化到极致	所有场景都应先完成
第二步	引入检索增强方案	问题涉及外部知识，或提示词缺少必要事实
第三步	考虑使用微调	前两步走不通，且问题确实适合微调

这套阶梯的关键不是三种技术谁更高级，而是上一级没有解决问题，再进入下一级。

第一步：先把提示词优化到极致

面对格式、语气和规则执行问题，第一步不是训练，而是先验证提示词能否解决。只要提示词仍有优化空间，就不能轻易得出“必须微调”的结论。

第二步：需要外部知识时引入检索

如果问题来自知识缺失，就通过检索把业务文档、规章制度或行业事实提供给模型。检索负责补齐事实，也保留了知识更新的灵活性。

第三步：最后才考虑微调

只有提示词已经反复优化、检索也已经覆盖所需事实，问题依然存在时，微调才真正进入决策范围。

微调应该是阶梯的第三层，而不是项目启动后的默认配置。

真正需要微调的三个信号

“微调不是起点”不等于“永远不做微调”。当下面三个信号出现时，微调就可能具备明确的工程价值。

信号一：行为与格式仍然不稳定

业务要求模型稳定输出特定结构、固定语气或复杂规则，但提示词经过反复优化后，效果仍然时好时坏。

这里有两个必要前提：

目标是约束模型的行为与输出形态；
提示词优化已经充分尝试，但稳定性仍未达标。

两个条件同时成立，才说明问题可能需要通过微调进一步固化。

信号二：高频窄口径任务受到成本与延迟制约

意图分类、实体抽取、内容打标这类任务，通常口径明确、调用频率高。为了让模型准确执行规则，系统可能需要在每一次请求中重复携带很长的提示词。

长提示词会带来持续的重复开销，也会增加延迟。此时，把任务行为通过微调迁移到小模型中，能够大幅降低成本和延迟。

这里决定是否微调的，不只是效果，还有调用规模下的长期成本。

信号三：距离业务硬指标只差最后几个点

提示词已经做到位，检索也已经补齐事实，但准确率距离业务硬指标仍然差最后几个点。这说明低成本手段已经基本用尽，而剩余差距又会直接影响业务上线或验收。

此时，微调才适合作为继续突破能力边界的手段。

三个信号可以浓缩成一张判断表：

信号	关键问题	微调价值
行为与格式	提示词反复优化后，输出仍不稳定吗？	固化结构、语气和复杂规则
成本与延迟	高频窄任务是否长期重复携带长提示词？	用小模型降低持续成本与延迟
能力边界	提示词和检索都到位后，是否仍差硬指标最后几个点？	进一步提升专项准确率

微调最常见的四个坑

真正的工程风险往往不在“会不会训练”，而在于微调目标、数据和评估是否正确。下面四个问题尤其常见。

坑一：用微调灌知识

把业务文档或行业知识直接拿去微调，看起来像是在“教会模型”，实际很容易让知识变成模型中的模糊印象，反而更容易胡说。

更麻烦的是，知识会持续变化。一旦知识固化进模型权重，每次更新都可能重新触发数据准备和训练，维护成本极高。

因此，这条边界要足够明确：

知识类需求永远优先走检索，不要用微调灌知识。

坑二：重数量，轻质量

微调数据不是越多越好。几百条高质量、统一口径的样本，效果可能好过几万条脏数据。

数据中的口径冲突和错误示范，会直接让模型学到不稳定的行为。与其盲目追求数量，不如先确保样本准确、清晰且规则一致。

对于简单任务，50～100 条样本就能看到明显效果。这意味着，微调项目早期更应该关注样本质量，而不是先堆出庞大的数据规模。

坑三：忽视灾难性遗忘

模型在窄任务上被过度微调后，可能出现通用能力退化。专项任务的指标变好，并不代表整体效果一定更好。

因此，微调后的评估不能只盯着目标任务，必须同时检查：

专项能力是否提升；
通用能力是否退化。

只有两者一起评估，才能判断这次微调是否真的值得上线。

坑四：没有评估就开始微调

没有评估体系就直接训练，相当于闭着眼睛开车：训练完成后，既无法确认效果提升了多少，也无法判断出现了哪些退化。

正确的顺序应该是：评估集先于训练搭建。

先明确用什么样本和标准验证效果，再开始准备微调。否则，训练过程即使顺利完成，也无法形成可信的工程结论。

一套可落地的决策顺序

面对“当前场景是否需要微调”，可以按下面的顺序做判断：

决策步骤	要回答的问题	对应动作
1. 定义问题	缺的是外部知识，还是行为稳定性？	知识问题走检索；行为问题继续判断
2. 优化提示词	提示词是否已经反复优化到位？	没有则继续优化，不急于微调
3. 补齐知识	是否缺少业务文档、制度或行业事实？	引入 RAG，不把知识写进权重
4. 检查信号	是否出现行为不稳、成本延迟或能力边界信号？	信号明确后再立项微调
5. 搭建评估	是否已有专项与通用能力评估？	评估集就绪后才开始训练
6. 准备数据	样本是否高质量且口径统一？	先保证质量，再考虑数量

这套顺序体现的不是对微调的保守，而是对工程成本和方案边界的尊重。

面试时应该怎样回答？

如果面试官问“什么时候做微调”，一个逻辑完整的回答可以这样组织：

我会先判断这是知识问题还是行为问题。模型缺少业务文档、规章制度或行业事实时，优先使用 RAG，因为知识需要灵活更新，不应该固化进模型权重。模型已经知道正确内容，但格式、语气或判断规则在提示词反复优化后仍不稳定，才是微调的适用场景。

在方案顺序上，我会先把提示词优化到极致，再引入检索增强，前两步走不通后才考虑微调。真正推动微调立项的信号主要有三个：行为和格式仍然不稳定；高频窄口径任务受长提示词的成本与延迟影响；提示词和检索都到位后，准确率距离业务硬指标仍差最后几个点。

开始训练前，我会先搭建评估集，并保证训练样本高质量、口径统一。评估时同时关注专项能力和通用能力，避免窄任务过度微调导致灾难性遗忘。

这个回答覆盖了问题分类、方案优先级、成本判断和上线风险，也更接近真实工业场景中的技术决策方式。

总结

大模型项目中，微调最容易被误用的原因，是团队把所有效果问题都归结为“模型能力不够”。但真正需要先回答的是：模型缺的是事实，还是稳定执行规则的行为？

整套决策可以压缩为三句话：

知识问题优先用 RAG，行为问题才考虑微调；
先提示词，再检索，最后才是微调；
没有明确微调信号、评估集和高质量数据，就不要启动训练。

成熟的工业界方案，往往是：

微调管形态，检索管事实。

但要特别注意：这是一套经过逐级验证后形成的终局组合方案，不是项目一开始就要全部开启的技术清单。

真正专业的选型，不是把所有技术都用上，而是在正确的问题上使用正确的手段。

Classic interview question:How exactly should you set RAG retrieval top-k?

Wed, 08 Jul 2026 22:05:00 +0800

经典面试题：RAG 检索 top-k 到底怎么设？

面试官问：“你们 RAG 系统的 top-k 是怎么设的？” 你如果只回答一句"看情况"，那基本就和 offer 说再见了。top-k 这个看似简单的参数，背后考的是你对完整 RAG 链路的理解深度。本文参考「小哲讲 agent 面试」的拆解思路，把这个高频面试题一次讲透。

一、为什么 top-k 是必考题？

在 RAG（Retrieval-Augmented Generation）系统中，top-k 决定从向量数据库里召回多少条文档片段喂给大模型。它看起来只是 search_kwargs={"k": 4} 这么一个参数，但它同时牵动四件事：

维度	top-k 的影响
召回率（Recall）	k 太小 → 漏掉真正相关的片段
噪声（Noise）	k 太大 → 召回一堆无关片段干扰生成
成本（Cost）	k 越大 → Prompt 越长 → token 费用越高、延迟越高
生成质量（Quality）	噪声片段会让 LLM “迷失在中间”，答非所问

也就是说，top-k 是召回、噪声、成本、质量四个目标的交汇点。面试官真正想听的不是"我设成了 5"，而是"我为什么这样设，背后是什么链路思维"。

二、top-k 设小了：幻觉的温床

很多人凭直觉认为"检索结果越靠前越相关，取 Top-1 不就行了？"——这是第一个坑。

问题在于：排名第一 ≠ 信息完整。

举个真实场景：用户问"公司请假流程是什么？"，向量库里有一份《员工手册》第 3 章详细写了请假流程，但因为切分（chunking）策略，这段内容被切成两半：

片段 A（排名第 1）："……请假需提前在 OA 系统提交申请，由直属主管审批。"
片段 B（排名第 2）：“超过 3 天的请假需提供医院证明，并报 HR 备案。”

如果你只取 Top-1，LLM 拿到的上下文只有"提交申请 + 主管审批"这一半，它大概率会编造“3 天以上需要什么材料”——因为用户问到了，它必须给出回答，但又没看到完整信息。这就是典型的幻觉：模型不是在撒谎，而是被不完整的上下文逼着"脑补"。

核心结论：top-k 设小的代价是召回不足 → 上下文不完整 → 模型幻觉。排名第一只能保证"最相关"，不能保证"最完整"。

三、top-k 设大了：噪声与成本的双重暴击

那干脆设大点，k=20、k=50 总不会漏了吧？这是第二个坑。

k 太大会引入三类问题：

3.1 噪声淹没信号

向量检索本质是相似度排序，但"相似"不等于"相关"。当 k=20 时，后 10 条往往是"看起来有点像但其实没用"的片段。这些噪声片段进入 Prompt 后，会触发 LLM 的 “Lost in the Middle” 现象——模型对上下文中间位置的信息注意力会下降，反而把真正相关的片段忽略了。

3.2 成本线性增长

LLM 的推理成本是按 token 计费的，k 越大，Prompt 越长：

k=4：上下文约 2000 token
k=20：上下文约 10000 token

成本直接 5 倍，延迟也跟着涨。线上高 QPS 场景下，这是真金白银的浪费。

3.3 生成质量下降

更隐蔽的问题是：噪声片段会让模型"分心"。LLM 是基于注意力机制的，当 Prompt 里混入大量无关内容，模型会尝试"综合"这些信息，导致回答跑题、啰嗦，甚至把无关片段当事实引用。

核心结论：top-k 设大的代价是噪声增加 → 成本上升 → 生成质量反而下降。多并不等于好。

四、两阶段检索：粗排 + 精排

既然 k 设小了漏、设大了吵，那有没有两全其美的办法？这就是**两阶段检索（Two-Stage Retrieval）**的价值。

4.1 第一阶段：粗排（Recall）——宁可错杀，不可放过

用什么：双塔 Embedding 模型（如 bge-large-zh、text-embedding-3）
怎么做：query 和 doc 分别编码，算余弦相似度
k 设多大：放宽到 20~50，甚至 100
目标：高召回率，把可能相关的片段都捞进来，哪怕混入噪声

这一步本质是"撒大网"，速度快（向量检索毫秒级），但精度有限。

4.2 第二阶段：精排（Precision）——去伪存真

用什么：Cross-Encoder 重排模型（如 bge-reranker-large、Cohere Rerank）
怎么做：把 query 和每一条候选 doc 拼在一起送进模型，输出相关性分数
取多少：按分数从高到低取 3~5 条 喂给 LLM
目标：高精度，把粗排里的噪声过滤掉，只留真正相关的

这一步是"过筛子"，精度高（Cross-Encoder 能捕捉 query-doc 的细粒度交互），但速度慢，所以只对粗排的少量候选做。

4.3 为什么不能直接用 Cross-Encoder 检索？

因为 Cross-Encoder 没有"索引"概念，必须对库里每条 doc 都跑一次模型，百万级文档库根本扛不住。所以工业界的标准做法就是：

双塔粗排（快但糙）→ Cross-Encoder 精排（慢但准）→ 取 Top-N 喂 LLM

这正是 top-k 在两阶段里的"分工"——粗排的 k 大（保召回），精排后的 k 小（保质量）。面试时把这两个 k 区分开讲，就已经超过 80% 的候选人了。

五、动态阈值：让输入规模自适应

两阶段检索解决了"召回 vs 精度"的矛盾，但还有一个问题：精排后取几条？固定取 3 条还是 5 条？

固定数字依然不够好，因为不同问题的"答案密度"不一样：

简单事实题（“公司全称是什么”）：可能只有 1 条强相关，取 5 条全是噪声
复杂流程题（“请假流程”）：可能需要 4~5 条片段拼起来才完整
开放性问题（“总结公司福利”）：可能需要 8~10 条覆盖不同福利项

这就引出动态阈值（Dynamic Threshold）：

5.1 基于分数的截断

不固定数量，而是设一个相关性分数阈值 θ：

`1`	`保留所有 score >= θ 的片段`

比如精排分数分布是 [0.92, 0.88, 0.85, 0.41, 0.38, ...]，阈值设 0.5，那就只取前 3 条，后边的低分噪声自动丢弃。

5.2 基于分数差距的截断（Drop-off 检测）

观察相邻分数的"断崖"：

`1`	`分数：0.92 → 0.88 → 0.85 → 0.41（断崖！）`

在分数急剧下降的位置截断，能自适应地保留"高分组"而丢弃"低分组"。

5.3 加上上下文长度约束

当然，动态阈值还要和 LLM 的上下文窗口配合——总不能召回 50 条全塞进去。实际工程里通常是：

`1`	`最终输入 = min(动态阈值筛出的片段, 上下文长度预算)`

核心结论：动态阈值让"取几条"从静态参数变成自适应决策，这是 top-k 的高阶玩法，也是面试加分项。

六、完整链路：top-k 不是参数，是思维

把前面几节串起来，你会看到 top-k 背后其实是一条完整的链路：

用户 Query
   ↓
[Query 改写]（可选：HyDE / Multi-Query / Step-back）
   ↓
[粗排] 双塔 Embedding 检索 → top-k₁ = 20~50（保召回）
   ↓
[精排] Cross-Encoder Rerank → 重排打分
   ↓
[截断] 动态阈值 / Drop-off 检测 → top-k₂ = 3~5（保质量）
   ↓
[上下文压缩]（可选：LongLLMLingua）
   ↓
[Prompt 拼装] Context + Question
   ↓
[LLM 生成] → 可溯源回答

每个环节都有它的"k"：

k₁（粗排）：大，保召回
k₂（精排后）：小，保质量
k₃（最终输入）：受动态阈值和上下文预算双重约束

面试官听到你能区分 k₁、k₂、k₃，并解释清楚每一步的目标，基本就认定你真正做过 RAG 工程，而不是只会调 LangChain 的 search_kwargs={"k": 4}。

七、面试高分回答模板

如果被问到"top-k 怎么设"，可以这样组织回答（约 90 秒）：

第一层：先承认 trade-off（10 秒）

“top-k 不是孤立参数，它同时影响召回率、噪声、成本和生成质量，设小了会漏、设大了会吵，所以不能一刀切。”

第二层：讲两阶段检索（40 秒）

“我们的做法是两阶段检索。粗排用双塔 Embedding，k 设到 20~50，优先保召回；精排用 Cross-Encoder Rerank，比如 bge-reranker-large，对粗排结果重打分。Cross-Encoder 精度高但慢，所以只对少量候选做。”

第三层：讲动态阈值（25 秒）

“精排后不固定取几条，而是用动态阈值——设一个相关性分数下限，或者检测分数 drop-off 的断崖位置，自适应截断。再叠加 LLM 上下文长度预算做上限保护。”

第四层：回到本质（15 秒）

“本质上 top-k 考的不是调参，而是对 RAG 链路的理解——召回、排序、截断、生成，每个阶段都有它的 k。区分清楚 k₁、k₂、k₃，效果就稳了。”

八、常见追问与应对

面试官追问	参考回答要点
“粗排 k 设 50 不会太慢吗？”	向量检索是 ANN（近似最近邻），百万级库毫秒级，HNSW/IVF 索引加持下没问题
“Rerank 模型怎么选？”	中文用 `bge-reranker-large`，英文用 Cohere Rerank；轻量场景可用 `bge-reranker-base`
“动态阈值怎么调？”	离线评估集上扫阈值，看 Recall@k 和 Precision@k 的 F1 拐点；或用分数分布的肘部
“为什么不直接用长上下文模型塞进去？”	长上下文有 Lost-in-the-Middle、成本高、不可溯源三个问题，RAG 仍然是更经济的方案
“k 设大了模型答非所问怎么办？”	先加 Rerank，再加动态阈值；必要时上 LongLLMLingua 做上下文压缩
“如何评估 top-k 设得对不对？”	用 Ragas / TruLens 做 Faithfulness、Context Recall、Answer Relevancy 三项指标评估

总结

回到那个面试题——“RAG 检索的 top-k 怎么设？”

低分回答：“看情况，一般设 3~5。”

及格回答：“设小了会幻觉，设大了会引入噪声，所以要在召回和精度之间权衡。”

高分回答：

top-k 不是单一参数，而是贯穿 RAG 链路的协同设计。粗排用双塔 Embedding 大 k 保召回（20~50），精排用 Cross-Encoder 重排提精度，再用动态阈值自适应截断到 3~5 条，最后受 LLM 上下文预算约束。本质考的不是调参，而是对召回 → 排序 → 截断 → 生成整条链路的理解。

记住视频里那句点睛之笔：

“top-k 的本质是完整 RAG 链路思维，而非调参数。”

把这句话在面试里讲出来，配合上面的链路图，这道题基本就稳了。

本文参考抖音「小哲讲 agent 面试」的视频内容整理扩展，原视频链接见文末。封面图由作者自行添加。

RAG Fully Explained:From "Closed-Book" to "Open-Book" LLMs

Wed, 08 Jul 2026 15:00:00 +0800

RAG 技术全景：让大模型从"闭卷考试"到"开卷考试"

大模型很强，但它会"一本正经地胡说八道"。RAG（Retrieval-Augmented Generation，检索增强生成）给大模型外挂了一个"知识库"，让它从闭卷考试变成开卷考试，回答既准又能溯源。本文用 6 张图带你完整搞懂 RAG。

一、先聊痛点：大模型的"幻觉"从哪来？

你大概遇到过这样的场景：问 GPT 一个公司内部的政策问题，或者让它总结一份最新发布的财报，它信誓旦旦地给你一段听起来很专业的回答——但仔细一查，全是编的。

这就是大模型的幻觉（Hallucination）。它不是故意的，而是由其工作方式决定的：LLM 本质上是在做"下一个 token 预测"，它根据训练时记住的概率分布生成文本，分不清"知道"和"不知道"。

原生 LLM 在企业级场景下有四个硬伤：

知识截止：训练数据有截止日期，不知道今天发生的事
幻觉问题：没见过的知识就靠"编"，还很自信
领域知识不足：对企业内部文档、专业细分领域不熟悉
无法溯源：回答不知道来自哪里，没法核验

要解决这些问题，传统思路是微调（Fine-tuning）——用领域数据重新训练模型。但微调又贵又慢，而且知识一更新就得再来一遍。

RAG 给了另一条路：不重新训练模型，而是给它外挂一个可随时更新的知识库，回答时先去知识库里检索，再基于检索到的内容作答。

就像考试一样：原生 LLM 是闭卷考试，全凭记忆，记不清就编；RAG 是开卷考试，遇到不会的可以翻书，答案有据可循。

二、RAG 是什么：核心思想一句话

RAG = 检索（Retrieval）+ 增强（Augmentation）+ 生成（Generation）

在 LLM 生成回答之前，先从外部知识库中检索相关资料，把这些资料增强到 Prompt 里作为上下文，再让 LLM 基于这些上下文生成回答。

用一句话概括：RAG 让 LLM 从"闭卷考试"变成"开卷考试"。

它和微调的根本区别在于：微调把知识"烧进"模型权重里，RAG 把知识放在模型之外的数据库里，用的时候现查。这也决定了两者的适用边界——后面会详细对比。

三、RAG 工作流程：三阶段详解

RAG 的完整流程可以拆成离线建库和在线问答两大阶段。在线问答又分为检索、增强、生成三步。

3.1 离线阶段：把文档变成可检索的向量库

这一步是"建图书馆"的过程，通常一次性完成，知识更新时增量重建：

文档加载：读取 PDF、Word、HTML、Markdown 等原始文档
切分（Chunking）：把长文档切成小段。为什么不整篇存？因为检索时要找最相关的片段，整篇文档向量会"稀释"语义；而且 LLM 上下文有限，塞不下整篇
向量化（Embedding）：用嵌入模型把每段文本转成一个高维向量（通常 768~1536 维），语义相近的文本在向量空间里距离也近
存入向量数据库：把向量和原文一起存进去，建好索引，供后续快速检索

3.2 在线阶段：检索 → 增强 → 生成

用户每一次提问，都会实时跑这三步：

① 检索 Retrieval

把用户问题用同一个 Embedding 模型转成向量
在向量数据库中做相似度检索（通常用余弦相似度），召回 Top-K（一般 3~10 条）最相关的文档片段

② 增强 Augmentation

把检索到的片段拼到 Prompt 模板里，作为上下文
一个典型的 Prompt 长这样：

你是一个严谨的问答助手，请根据以下参考资料回答用户问题。
如果资料中没有答案，请回答"根据现有资料无法回答"，不要编造。

【参考资料】
{检索到的文档片段1}
{检索到的文档片段2}
...

【用户问题】
{用户的问题}

③ 生成 Generation

把拼好的 Prompt 喂给 LLM，生成最终回答
可以要求模型在回答中标注引用来源，实现可溯源

四、完整架构图

这张图把离线和在线两条流水线放在了一起。注意几个关键点：

Embedding 模型必须一致：离线建库用哪个模型，在线检索时也要用同一个，否则向量空间不兼容
知识更新无需重训模型：新增文档只需走一遍"切分 → 向量化 → 入库"，模型权重完全不动
检索质量是 RAG 的命门：如果第一步召回的片段就不相关，后面 LLM 再强也答不好

五、核心组件选型

RAG 系统由四个核心组件构成，选型直接影响效果：

组件	作用	常见选型
Embedding 模型	文本转向量，决定语义匹配上限	BGE（智源）、M3E、OpenAI text-embedding-3、Cohere、bge-m3
向量数据库	存储与检索向量	Milvus、Qdrant、Chroma、Pinecone、FAISS、Weaviate
LLM	基于上下文生成回答	GPT-4、Claude、Qwen、DeepSeek、Llama、GLM
编排框架	串联整个流程	LangChain、LlamaIndex、Haystack、DSPy

几个选型经验：

中文场景：Embedding 优先考虑 bge-large-zh 或 bge-m3，比 OpenAI 的英文模型在中文检索上更准
轻量起步：向量库用 Chroma（纯 Python，单机嵌入式）跑通流程，量大了再换 Milvus / Qdrant
框架选择：快速原型用 LangChain，文档密集型场景用 LlamaIndex（它对文档处理和索引抽象更细致）

六、进阶技术：从"能用"到"好用"

朴素 RAG（一次向量检索 + 拼 Prompt）能跑通，但效果往往一般。真正生产级的 RAG 通常会在四个方向上做增强：

6.1 Query 改写（让问题更适合检索）

用户的问题往往是口语化、模糊的，直接拿去检索效果差。常见技巧：

Query Rewriting：让 LLM 把"那个东西怎么用"改写成"产品 X 的使用方法"
HyDE（Hypothetical Document Embeddings）：先让 LLM 生成一个假设性答案，再用这个答案的向量去检索——因为"答案"和"答案"的语义比"问题"和"答案"更接近
Multi-Query：把一个问题拆成多个子问题分别检索，结果合并去重
Step-back Prompting：先抽象出上位概念再检索，比如"2024 年诺贝尔物理学奖得主"先退到"诺贝尔物理学奖近年得主"

6.2 混合检索 + Rerank（多路召回，精排提纯）

单靠向量检索有个问题：它擅长语义匹配，但对专有名词、产品型号、人名这种精确字面匹配反而不如传统检索。所以生产系统通常用混合检索：

向量检索（语义）+ BM25 关键词检索（字面）并行召回
用 RRF（Reciprocal Rank Fusion） 融合两路结果
再用 Cross-Encoder 重排模型（如 bge-reranker-large、Cohere Rerank）对召回结果做精排
最后取 Top-K 喂给 LLM

Rerank 的关键区别：Embedding 是把 query 和 doc 分别编码再算相似度（双塔），而 Cross-Encoder 是把 query 和 doc 拼一起送进模型（交叉编码），精度高得多，但速度慢——所以先用向量检索粗筛，再用 Rerank 精排，兼顾速度和精度。

6.3 GraphRAG：基于知识图谱的全局检索

微软 2024 年提出的 GraphRAG 解决的是朴素 RAG 的另一个痛点：局部性。向量检索只能召回和问题相似的片段，回答不了"总结整个文档集的核心主题"这种全局性问题。

GraphRAG 的做法：

用 LLM 从文档中抽取实体和关系，构建知识图谱
用社区检测算法（如 Leiden）把图谱分成主题层次化的社区
为每个社区生成摘要
查询时根据问题粒度选择社区摘要或具体节点回答

它特别适合"全局性总结"“跨文档推理"类问题，代价是建图成本高、更新麻烦。

6.4 Self-RAG / 自适应 RAG：让模型自己决定要不要检索

不是每个问题都需要检索——“1+1 等于几"还去查库就浪费了。Self-RAG 让模型学会自我反思：

是否检索：判断问题是否需要外部知识，简单问题直接答
检索结果是否相关：过滤掉无关片段
生成是否忠于检索：检查答案有没有脱离资料编造

好处是省 token、降延迟，坏处是需要训练模型学会这些判断（或用 prompt 模拟），实现复杂度高。

七、方案对比：RAG vs 微调 vs 长上下文

随着模型上下文窗口越来越长（Claude 200K、Gemini 1M、GPT-4o 128K），有人质疑 RAG 是不是过时了——直接把所有文档塞进上下文不就行了？

实际并非如此，三者各有定位：

长上下文：贵（按 token 计费）、易"迷失在中间”（Lost in the Middle 现象）、不可溯源。适合一次性分析单份长文档
RAG：经济、可扩展到海量文档、可溯源。适合知识库问答
微调：改变模型行为/风格，而非注入事实知识。适合固定格式输出、领域术语适配
RAG + 微调：效果最好，成本最高，用于高精度专业场景

经验法则：知识频繁变化 → RAG；风格/格式固定 → 微调；两者都要 → 结合用。

八、实战：用 LangChain 跑通一个最小 RAG

理论讲完，来看一段能跑的代码。用 LangChain + Chroma + OpenAI 实现 30 行的 RAG：

from langchain_community.document_loaders import TextDocumentLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

# ① 离线建库：加载 → 切分 → 向量化 → 入库
docs = TextDocumentLoader("knowledge.txt").load()
chunks = RecursiveCharacterTextSplitter(
    chunk_size=500, chunk_overlap=50      # 500 字一段，重叠 50 字
).split_documents(docs)
vectorstore = Chroma.from_documents(
    chunks, OpenAIEmbeddings(model="text-embedding-3-small")
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})  # 召回 Top-4

# ② 在线问答：检索 → 增强 → 生成
prompt = ChatPromptTemplate.from_template("""
你是严谨的问答助手，根据以下资料回答问题。资料中没有答案就说"无法回答"，不要编造。

【资料】
{context}

【问题】
{question}
""")

def format_docs(docs):
    return "\n\n".join(d.page_content for d in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | ChatOpenAI(model="gpt-4o-mini", temperature=0)
    | StrOutputParser()
)

# ③ 提问
print(rag_chain.invoke("公司请假流程是什么？"))

这段代码虽然简单，但已经包含了 RAG 的所有核心环节。生产化时再把 Embedding 换成 BGE、加上 Rerank、换成 Milvus，骨架不变。

九、常见挑战与优化方向

实际落地 RAG，踩坑往往不在模型，而在检索。下面是常见问题对应的优化手段：

症状	根因	优化方向
检索结果不相关	Query 与文档语义差距大	Query 改写、换更强的 Embedding
召回准确但答非所问	片段顺序/噪声干扰	加 Rerank 精排、调 Top-K
答案不忠于资料	LLM 忽略上下文编造	Prompt 加约束、降 temperature、强制引用
专有名词召回差	纯向量检索短板	加 BM25 混合检索
上下文超长	召回太多塞不下	上下文压缩、LongLLMLingua、换长上下文模型
知识更新延迟	索引重建慢	增量索引、流式更新
答案无法溯源	未保留片段来源	检索结果带 metadata，Prompt 要求标注引用

一个经验：80% 的 RAG 优化工作都在检索阶段，而不是生成阶段。先把检索做准，效果立刻提升一大截。

十、典型应用场景

企业知识问答：基于内部 Wiki、手册、合同的智能客服与员工助手
法律/医疗咨询：基于法条、判例、药品说明、病历的精准问答
代码助手：基于私有代码库的代码生成（Cursor、Copilot Workspace 都用了 RAG 思想）
教育辅导：基于教材的个性化答疑，答案可指向课本页码
智能搜索：搜索引擎的 AI 摘要（Perplexity、Bing Chat、Google AI Overviews）
数据分析：Text-to-SQL，基于数据库 schema 的自然语言查询

总结

RAG 不是某个具体工具，而是一种 “把外部知识检索和大模型生成结合起来” 的架构思想。它的价值在于：让大模型能用最新、最准、可溯源的外部知识来回答问题，而无需重新训练。

回顾本文要点：

核心思想：检索 → 增强 → 生成，让 LLM 从闭卷变开卷
两大阶段：离线建库（切分+向量化+入库）+ 在线问答（检索+增强+生成）
命门在检索：80% 的优化工作都在检索阶段
进阶四件套：Query 改写、混合检索+Rerank、GraphRAG、Self-RAG
方案选择：知识频繁变化用 RAG，风格固定用微调，高精度场景结合使用

随着模型上下文窗口变长、多模态能力增强，RAG 的形态还在演进（比如多模态 RAG、Agentic RAG），但"外挂知识库"这个核心思想短期内不会过时——毕竟，开卷考试永远比背书更可靠。

如果你对其中某个环节（比如向量数据库选型、Embedding 微调、GraphRAG 实现）想深入，欢迎在评论区交流。