AI搜索 企业级实战方案｜附完整命令

在企业数字化转型进入深水区之后，数据已经不再只是“存起来”的资产，而是需要被快速理解、检索、关联和决策支撑的生产力工具。过去，企业内部的信息检索主要依赖关键词搜索，例如在文档库、知识库、工单系统、CRM、OA、代码仓库中输入关键词，然后由员工自行筛选结果。但随着非结构化数据规模急剧增长，传统搜索越来越难以满足业务需求。

AI搜索，尤其是基于大语言模型、向量数据库、语义检索和RAG（Retrieval-Augmented Generation，检索增强生成）的企业级搜索方案，正在成为新一代企业知识基础设施。它不仅能“搜到文档”，还能理解用户问题、定位相关知识、总结答案、给出引用来源，并与企业权限体系、审计体系和业务系统深度集成。

本文将从企业级落地角度，完整介绍一套可部署、可扩展、可运维的AI搜索实战方案，并附上从环境准备、模型部署、向量数据库、文档解析、索引构建、API服务到前端访问的完整命令示例。

一、为什么企业需要AI搜索？

传统企业搜索主要解决的是“信息在哪里”的问题，而AI搜索进一步解决的是“答案是什么、依据是什么、下一步怎么做”。

例如，员工可能会问：

“公司差旅报销中，高铁一等座是否可以报销？”
“某个客户过去三个月提交了哪些高优先级工单？”
“这份合同里有哪些付款风险？”
“研发规范中关于接口幂等性的要求是什么？”
“请总结一下2024年销售会议纪要中关于华东区域的增长计划。”

如果依靠传统关键词搜索，用户通常需要打开多个文档，手动比对、阅读和归纳。而AI搜索可以直接返回结构化答案，并附带来源文档、段落位置和可信引用。

企业引入AI搜索的核心价值包括：

1. 提升知识获取效率
   员工无需反复翻阅文档，即可获得接近自然语言问答的体验。

2. 降低知识传承成本
   老员工经验、流程制度、项目资料、客户信息可以沉淀为可查询的企业知识库。

3. 增强决策质量
   AI搜索可以跨系统聚合信息，为管理层、销售、客服、研发、法务提供辅助判断。

4. 提升客服与内部支持效率
   IT服务台、人事政策咨询、财务报销、售后客服都可以使用AI搜索降低人工压力。

5. 避免大模型幻觉
   通过RAG机制，让模型基于企业真实资料回答，并提供引用来源，降低“编答案”的风险。

二、企业级AI搜索总体架构

一个完整的企业级AI搜索系统通常包括以下模块：

数据源
 ├── 企业文档：PDF、Word、Excel、PPT、Markdown、TXT
 ├── 业务系统：CRM、ERP、OA、工单、知识库、邮件
 ├── 数据库：MySQL、PostgreSQL、SQL Server、MongoDB
 └── 代码仓库：GitLab、GitHub Enterprise、SVN

数据处理层
 ├── 文档解析
 ├── OCR识别
 ├── 文本清洗
 ├── 分段切片
 ├── 元数据提取
 └── 权限标记

AI能力层
 ├── Embedding向量模型
 ├── 大语言模型LLM
 ├── 重排序模型Reranker
 └── Prompt模板

检索层
 ├── 向量数据库
 ├── 全文检索引擎
 ├── 混合检索
 └── 权限过滤

应用服务层
 ├── 问答API
 ├── 文档检索API
 ├── 管理后台
 ├── 审计日志
 └── 监控告警

用户入口
 ├── Web搜索页面
 ├── 企业微信/钉钉/飞书机器人
 ├── 浏览器插件
 ├── 内部系统嵌入
 └── API调用

企业级AI搜索不是简单地把文档丢给大模型，而是一个“数据治理 + 检索系统 + 模型服务 + 权限安全 + 运维监控”的综合工程。

三、技术选型建议

本文以一套较为通用、易于私有化部署的方案为例：

如果企业对数据安全要求较高，建议采用完全私有化部署；如果处于试点阶段，也可以采用“企业数据本地处理 + 外部模型API”的混合方案，但需要注意脱敏、访问控制和合规审计。

四、服务器准备

以下命令以Ubuntu 22.04为例。

1. 更新系统

sudo apt update && sudo apt upgrade -y

2. 安装常用工具

sudo apt install -y curl wget git vim unzip htop net-tools lsof jq build-essential

3. 安装Docker

curl -fsSL https://get.docker.com | bash
sudo systemctl enable docker
sudo systemctl start docker

4. 将当前用户加入Docker组

sudo usermod -aG docker $USER
newgrp docker

5. 安装Docker Compose插件

sudo apt install -y docker-compose-plugin
docker compose version

6. 创建项目目录

mkdir -p ~/enterprise-ai-search
cd ~/enterprise-ai-search

五、部署基础服务

我们先部署PostgreSQL、Redis、Milvus和Elasticsearch。

创建 docker-compose.yml：

cat > docker-compose.yml <<'EOF'
services:
  postgres:
    image: postgres:15
    container_name: ai_search_postgres
    restart: always
    environment:
      POSTGRES_USER: ai_search
      POSTGRES_PASSWORD: ai_search_password
      POSTGRES_DB: ai_search
    ports:
      - "5432:5432"
    volumes:
      - ./data/postgres:/var/lib/postgresql/data

  redis:
    image: redis:7
    container_name: ai_search_redis
    restart: always
    ports:
      - "6379:6379"
    command: redis-server --appendonly yes
    volumes:
      - ./data/redis:/data

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.12.2
    container_name: ai_search_es
    restart: always
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - ES_JAVA_OPTS=-Xms1g -Xmx1g
    ports:
      - "9200:9200"
    volumes:
      - ./data/elasticsearch:/usr/share/elasticsearch/data

  etcd:
    image: quay.io/coreos/etcd:v3.5.5
    container_name: ai_search_etcd
    restart: always
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
      - ETCD_AUTO_COMPACTION_RETENTION=1000
      - ETCD_QUOTA_BACKEND_BYTES=4294967296
    command: etcd -advertise-client-urls=http://127.0.0.1:2379 -listen-client-urls http://0.0.0.0:2379 --data-dir /etcd
    volumes:
      - ./data/etcd:/etcd

  minio:
    image: minio/minio:RELEASE.2024-01-16T16-07-38Z
    container_name: ai_search_minio
    restart: always
    environment:
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
    ports:
      - "9000:9000"
      - "9001:9001"
    command: minio server /minio_data --console-address ":9001"
    volumes:
      - ./data/minio:/minio_data

  milvus:
    image: milvusdb/milvus:v2.3.9
    container_name: ai_search_milvus
    restart: always
    command: ["milvus", "run", "standalone"]
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - etcd
      - minio
    volumes:
      - ./data/milvus:/var/lib/milvus
EOF

启动服务：

docker compose up -d

查看容器状态：

docker compose ps

检查Elasticsearch：

curl http://localhost:9200

检查PostgreSQL：

docker exec -it ai_search_postgres psql -U ai_search -d ai_search -c "SELECT version();"

六、部署Embedding模型服务

企业AI搜索的核心能力之一是Embedding，即把文本转换为向量。中文企业场景推荐使用 BAAI/bge-m3 或 BAAI/bge-large-zh-v1.5。

这里使用Python FastAPI封装一个Embedding服务。

1. 创建Python虚拟环境

cd ~/enterprise-ai-search
mkdir -p embedding-service
cd embedding-service

sudo apt install -y python3-venv python3-pip
python3 -m venv venv
source venv/bin/activate

2. 安装依赖

pip install -U pip
pip install fastapi uvicorn sentence-transformers torch

如果服务器有NVIDIA GPU，需要提前安装CUDA和驱动，并安装对应版本的PyTorch。例如：

pip install torch --index-url https://download.pytorch.org/whl/cu121

3. 编写Embedding服务

cat > app.py <<'EOF'
from fastapi import FastAPI
from pydantic import BaseModel
from sentence_transformers import SentenceTransformer
from typing import List

app = FastAPI(title="Enterprise AI Search Embedding Service")

model = SentenceTransformer("BAAI/bge-m3")

class EmbeddingRequest(BaseModel):
    texts: List[str]

@app.post("/embedding")
def embedding(req: EmbeddingRequest):
    vectors = model.encode(
        req.texts,
        normalize_embeddings=True,
        batch_size=16
    )
    return {
        "dimension": len(vectors[0]),
        "vectors": vectors.tolist()
    }

@app.get("/health")
def health():
    return {"status": "ok"}
EOF

4. 启动服务

uvicorn app:app --host 0.0.0.0 --port 8001

后台启动可以使用：

nohup uvicorn app:app --host 0.0.0.0 --port 8001 > embedding.log 2>&1 &

测试：

curl -X POST http://localhost:8001/embedding \
  -H "Content-Type: application/json" \
  -d '{"texts":["企业级AI搜索如何落地？"]}'

七、部署大语言模型服务

企业可以选择本地模型或外部API。这里给出两种方案。

方案一：使用Ollama快速部署本地模型

Ollama适合快速验证和中小规模场景。

安装Ollama：

curl -fsSL https://ollama.com/install.sh | sh

拉取Qwen模型：

ollama pull qwen2.5:7b

启动测试：

ollama run qwen2.5:7b

API调用测试：

curl http://localhost:11434/api/chat \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5:7b",
    "messages": [
      {"role": "user", "content": "请用一句话解释什么是RAG。"}
    ],
    "stream": false
  }'

方案二：使用vLLM部署生产级模型服务

如果企业有GPU服务器，建议使用vLLM以获得更高吞吐。

安装依赖：

python3 -m venv ~/vllm-env
source ~/vllm-env/bin/activate
pip install -U pip
pip install vllm

启动OpenAI兼容接口：

python -m vllm.entrypoints.openai.api_server \
  --model Qwen/Qwen2.5-7B-Instruct \
  --host 0.0.0.0 \
  --port 8000 \
  --served-model-name qwen2.5-7b-instruct

测试：

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5-7b-instruct",
    "messages": [
      {"role": "user", "content": "请解释企业AI搜索的核心架构。"}
    ],
    "temperature": 0.2
  }'

八、构建文档入库与索引流程

企业AI搜索的质量，很大程度取决于文档处理流程。常见步骤如下：

1. 上传或同步文档；
2. 提取文本内容；
3. 清洗无效字符；
4. 按语义或长度切分；
5. 调用Embedding模型生成向量；
6. 写入Milvus；
7. 写入Elasticsearch；
8. 保存文档元数据到PostgreSQL；
9. 记录权限、部门、标签、来源系统等信息。

九、初始化数据库表

进入项目目录：

cd ~/enterprise-ai-search
mkdir -p backend
cd backend

创建初始化SQL：

cat > init.sql <<'EOF'
CREATE TABLE IF NOT EXISTS documents (
    id SERIAL PRIMARY KEY,
    doc_id VARCHAR(128) UNIQUE NOT NULL,
    title TEXT NOT NULL,
    source TEXT,
    file_path TEXT,
    department VARCHAR(128),
    access_level VARCHAR(64),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE IF NOT EXISTS document_chunks (
    id SERIAL PRIMARY KEY,
    chunk_id VARCHAR(128) UNIQUE NOT NULL,
    doc_id VARCHAR(128) NOT NULL,
    chunk_index INT NOT NULL,
    content TEXT NOT NULL,
    metadata JSONB,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE IF NOT EXISTS search_logs (
    id SERIAL PRIMARY KEY,
    user_id VARCHAR(128),
    query TEXT NOT NULL,
    answer TEXT,
    retrieved_chunks JSONB,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
EOF

执行SQL：

docker cp init.sql ai_search_postgres:/init.sql
docker exec -it ai_search_postgres psql -U ai_search -d ai_search -f /init.sql

十、创建AI搜索后端服务

1. 安装依赖

cd ~/enterprise-ai-search/backend
python3 -m venv venv
source venv/bin/activate

pip install -U pip
pip install fastapi uvicorn requests psycopg2-binary pymilvus elasticsearch pydantic python-multipart pymupdf

2. 编写后端服务

cat > app.py <<'EOF'
import os
import uuid
import json
import requests
import fitz
import psycopg2
from typing import List
from fastapi import FastAPI, UploadFile, File
from pydantic import BaseModel
from pymilvus import connections, FieldSchema, CollectionSchema, DataType, Collection
from elasticsearch import Elasticsearch

POSTGRES_DSN = "dbname=ai_search user=ai_search password=ai_search_password host=localhost port=5432"
EMBEDDING_URL = "http://localhost:8001/embedding"
LLM_URL = "http://localhost:11434/api/chat"
LLM_MODEL = "qwen2.5:7b"

MILVUS_HOST = "localhost"
MILVUS_PORT = "19530"
COLLECTION_NAME = "enterprise_ai_search"

app = FastAPI(title="Enterprise AI Search Backend")

es = Elasticsearch("http://localhost:9200")

def get_pg_conn():
    return psycopg2.connect(POSTGRES_DSN)

def init_milvus():
    connections.connect(host=MILVUS_HOST, port=MILVUS_PORT)

    fields = [
        FieldSchema(name="chunk_id", dtype=DataType.VARCHAR, max_length=128, is_primary=True),
        FieldSchema(name="doc_id", dtype=DataType.VARCHAR, max_length=128),
        FieldSchema(name="content", dtype=DataType.VARCHAR, max_length=4096),
        FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=1024),
    ]

    schema = CollectionSchema(fields, description="enterprise ai search collection")

    try:
        collection = Collection(COLLECTION_NAME)
    except Exception:
        collection = Collection(COLLECTION_NAME, schema)

    index_params = {
        "metric_type": "IP",
        "index_type": "HNSW",
        "params": {
            "M": 16,
            "efConstruction": 200
        }
    }

    try:
        collection.create_index("embedding", index_params)
    except Exception:
        pass

    collection.load()
    return collection

collection = init_milvus()

def extract_pdf_text(file_path):
    doc = fitz.open(file_path)
    texts = []
    for page in doc:
        texts.append(page.get_text())
    return "\n".join(texts)

def split_text(text, chunk_size=600, overlap=100):
    chunks = []
    start = 0
    text = text.replace("\r", "\n")
    while start < len(text):
        end = start + chunk_size
        chunk = text[start:end].strip()
        if chunk:
            chunks.append(chunk)
        start += chunk_size - overlap
    return chunks

def get_embeddings(texts: List[str]):
    resp = requests.post(EMBEDDING_URL, json={"texts": texts}, timeout=120)
    resp.raise_for_status()
    return resp.json()["vectors"]

@app.post("/upload")
async def upload(file: UploadFile = File(...), department: str = "default", access_level: str = "internal"):
    os.makedirs("uploads", exist_ok=True)
    doc_id = str(uuid.uuid4())
    file_path = os.path.join("uploads", f"{doc_id}_{file.filename}")

    with open(file_path, "wb") as f:
        f.write(await file.read())

    if file.filename.lower().endswith(".pdf"):
        text = extract_pdf_text(file_path)
    else:
        text = open(file_path, "r", encoding="utf-8", errors="ignore").read()

    chunks = split_text(text)
    vectors = get_embeddings(chunks)

    conn = get_pg_conn()
    cur = conn.cursor()

    cur.execute(
        "INSERT INTO documents(doc_id,title,source,file_path,department,access_level) VALUES(%s,%s,%s,%s,%s,%s)",
        (doc_id, file.filename, "upload", file_path, department, access_level)
    )

    milvus_data = [[], [], [], []]

    for idx, chunk in enumerate(chunks):
        chunk_id = str(uuid.uuid4())
        metadata = {
            "title": file.filename,
            "department": department,
            "access_level": access_level,
            "chunk_index": idx
        }

        cur.execute(
            "INSERT INTO document_chunks(chunk_id,doc_id,chunk_index,content,metadata) VALUES(%s,%s,%s,%s,%s)",
            (chunk_id, doc_id, idx, chunk, json.dumps(metadata, ensure_ascii=False))
        )

        es.index(
            index="enterprise_ai_search",
            id=chunk_id,
            document={
                "chunk_id": chunk_id,
                "doc_id": doc_id,
                "content": chunk,
                "title": file.filename,
                "department": department,
                "access_level": access_level
            }
        )

        milvus_data[0].append(chunk_id)
        milvus_data[1].append(doc_id)
        milvus_data[2].append(chunk[:4000])
        milvus_data[3].append(vectors[idx])

    collection.insert(milvus_data)
    collection.flush()

    conn.commit()
    cur.close()
    conn.close()

    return {
        "doc_id": doc_id,
        "filename": file.filename,
        "chunks": len(chunks)
    }

class SearchRequest(BaseModel):
    query: str
    user_id: str = "anonymous"
    department: str = "default"
    top_k: int = 5

def vector_search(query, top_k):
    vector = get_embeddings([query])[0]
    search_params = {
        "metric_type": "IP",
        "params": {"ef": 64}
    }

    results = collection.search(
        data=[vector],
        anns_field="embedding",
        param=search_params,
        limit=top_k,
        output_fields=["chunk_id", "doc_id", "content"]
    )

    chunks = []
    for hits in results:
        for hit in hits:
            chunks.append({
                "chunk_id": hit.entity.get("chunk_id"),
                "doc_id": hit.entity.get("doc_id"),
                "content": hit.entity.get("content"),
                "score": float(hit.score)
            })
    return chunks

def keyword_search(query, top_k):
    resp = es.search(
        index="enterprise_ai_search",
        size=top_k,
        query={
            "match": {
                "content": query
            }
        }
    )
    chunks = []
    for hit in resp["hits"]["hits"]:
        src = hit["_source"]
        chunks.append({
            "chunk_id": src["chunk_id"],
            "doc_id": src["doc_id"],
            "content": src["content"],
            "score": float(hit["_score"])
        })
    return chunks

def build_prompt(query, chunks):
    context = "\n\n".join([
        f"资料{i+1}：{c['content']}" for i, c in enumerate(chunks)
    ])

    return f"""你是企业内部AI搜索助手。请严格基于以下资料回答用户问题。
如果资料中没有答案，请明确说明“根据现有资料无法确定”，不要编造。
回答需要简洁、准确，并尽量列出依据。

用户问题：
{query}

可参考资料：
{context}

请输出：
1. 直接答案
2. 依据说明
3. 相关来源编号
"""

def call_llm(prompt):
    resp = requests.post(
        LLM_URL,
        json={
            "model": LLM_MODEL,
            "messages": [
                {"role": "user", "content": prompt}
            ],
            "stream": False,
            "temperature": 0.2
        },
        timeout=180
    )
    resp.raise_for_status()
    return resp.json()["message"]["content"]

@app.post("/search")
def search(req: SearchRequest):
    vector_chunks = vector_search(req.query, req.top_k)
    keyword_chunks = keyword_search(req.query, req.top_k)

    merged = {}
    for c in vector_chunks + keyword_chunks:
        merged[c["chunk_id"]] = c

    chunks = list(merged.values())[:req.top_k]

    prompt = build_prompt(req.query, chunks)
    answer = call_llm(prompt)

    conn = get_pg_conn()
    cur = conn.cursor()
    cur.execute(
        "INSERT INTO search_logs(user_id,query,answer,retrieved_chunks) VALUES(%s,%s,%s,%s)",
        (req.user_id, req.query, answer, json.dumps(chunks, ensure_ascii=False))
    )
    conn.commit()
    cur.close()
    conn.close()

    return {
        "query": req.query,
        "answer": answer,
        "sources": chunks
    }

@app.get("/health")
def health():
    return {"status": "ok"}
EOF

3. 启动后端服务

uvicorn app:app --host 0.0.0.0 --port 8080

后台启动：

nohup uvicorn app:app --host 0.0.0.0 --port 8080 > backend.log 2>&1 &

测试健康检查：

curl http://localhost:8080/health

十一、上传企业文档

准备一个测试文档：

cat > test.txt <<'EOF'
公司差旅报销制度：
1. 员工出差应优先选择经济舱、高铁二等座。
2. 高铁一等座原则上不予报销，除非经部门负责人和财务负责人提前审批。
3. 住宿标准按照城市等级执行，一线城市每晚不超过600元。
4. 出差结束后，应在7个工作日内提交报销申请。
EOF

上传文档：

curl -X POST "http://localhost:8080/upload?department=finance&access_level=internal" \
  -F "file=@test.txt"

返回示例：

{
  "doc_id": "a2c9e2a2-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "filename": "test.txt",
  "chunks": 1
}

十二、执行AI搜索问答

curl -X POST http://localhost:8080/search \
  -H "Content-Type: application/json" \
  -d '{
    "query": "高铁一等座可以报销吗？",
    "user_id": "zhangsan",
    "department": "finance",
    "top_k": 5
  }'

预期回答类似：

{
  "query": "高铁一等座可以报销吗？",
  "answer": "1. 直接答案：高铁一等座原则上不予报销，但如果提前经过部门负责人和财务负责人审批，可以报销。\n\n2. 依据说明：资料中明确说明员工出差应优先选择高铁二等座，高铁一等座原则上不予报销，除非经相关负责人提前审批。\n\n3. 相关来源编号：资料1",
  "sources": [
    {
      "chunk_id": "...",
      "doc_id": "...",
      "content": "公司差旅报销制度：...",
      "score": 0.81
    }
  ]
}

十三、企业级必须增强的关键能力

上面的方案可以完成从文档入库到AI问答的基本闭环，但企业级生产环境还必须进一步强化以下能力。

1. 权限控制

企业AI搜索最容易被忽视的问题是权限。如果用户无权查看某份文档，就不能通过AI搜索间接获得其中内容。

建议权限设计包括：

• 文档级权限；
• 段落级权限；
• 部门权限；
• 用户角色权限；
• 来源系统权限；
• 密级权限；
• 用户组权限；
• 临时授权；
• 离职或转岗权限回收。

检索时必须先根据用户身份获取权限范围，再在向量检索和全文检索中过滤数据。

Milvus本身不适合承担复杂权限判断，因此常见做法是：

1. 向量库只负责召回候选内容；
2. 元数据数据库负责权限判断；
3. Elasticsearch支持部分过滤；
4. 最终进入Prompt前再次做权限过滤。

2. 混合检索

企业搜索中，单纯向量检索并不总是最佳。例如合同编号、客户编号、工单号、产品型号等精确字段，关键词检索效果更稳定。

建议采用混合检索：

最终结果 = 向量语义检索 + 关键词全文检索 + 结构化字段过滤 + Reranker重排序

常见策略：

• 语义问题优先向量检索；
• 编号、姓名、日期等优先关键词检索；
• 两路召回后统一去重；
• 使用Reranker模型重新排序；
• 将Top N结果送给大模型生成答案。

3. Reranker重排序

Embedding召回的是“可能相关”的内容，但排序并不总是精确。Reranker可以对“问题 + 文档片段”进行更细粒度相关性判断。

安装示例：

pip install FlagEmbedding

简单示例：

from FlagEmbedding import FlagReranker

reranker = FlagReranker("BAAI/bge-reranker-large", use_fp16=True)

scores = reranker.compute_score([
    ["高铁一等座可以报销吗？", "高铁一等座原则上不予报销，除非提前审批。"],
    ["高铁一等座可以报销吗？", "住宿标准按照城市等级执行。"]
])

print(scores)

生产中建议流程：

召回Top 50 -> Reranker排序 -> 取Top 5~10 -> 进入LLM

4. 文档切分策略

切分太短会导致上下文不完整，切分太长会降低检索精度并浪费Token。

建议：

• 制度类文档：按标题、条款、自然段切分；
• FAQ类文档：按问答对切分；
• 合同类文档：按章节和条款切分；
• 会议纪要：按议题切分；
• 代码文档：按函数、类、模块切分；
• 表格数据：按行、业务实体或主题切分。

推荐切片长度：

中文普通文档：300～800字
技术文档：500～1200字
FAQ：一个问答对为一个chunk
合同条款：按条款切分
Overlap：50～150字

5. 引用来源与可追溯

企业AI搜索不能只给答案，还要给依据。每个答案都应包含：

• 文档标题；
• 章节名称；
• 页码；
• 段落编号；
• 更新时间；
• 来源系统；
• 权限级别；
• 命中片段；
• 相似度分数。

这不仅有助于用户验证答案，也有助于企业审计和合规。

6. 防止幻觉

建议在Prompt中加入强约束：

你必须严格基于提供的资料回答。
如果资料不足，请回答“根据现有资料无法确定”。
不得编造政策、数字、日期、人员姓名或审批流程。
所有结论必须能在资料中找到依据。

此外，还可以加入：

• 低相关度拒答；
• 多来源一致性校验；
• 答案置信度；
• 引用覆盖率检查；
• 敏感问题人工复核；
• 高风险场景禁止自动决策。

十四、生产环境部署建议

1. 使用Nginx反向代理

安装Nginx：

sudo apt install -y nginx

创建配置：

sudo tee /etc/nginx/sites-available/ai-search <<'EOF'
server {
    listen 80;
    server_name ai-search.example.com;

    location /api/ {
        proxy_pass http://127.0.0.1:8080/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_read_timeout 300;
    }

    location /embedding/ {
        proxy_pass http://127.0.0.1:8001/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}
EOF

启用配置：

sudo ln -s /etc/nginx/sites-available/ai-search /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

2. 使用systemd守护服务

创建后端服务：

sudo tee /etc/systemd/system/ai-search-backend.service <

sudo systemctl daemon-reload
sudo systemctl enable ai-search-backend
sudo systemctl start ai-search-backend
sudo systemctl status ai-search-backend

sudo tee /etc/systemd/system/ai-search-embedding.service <

sudo systemctl daemon-reload
sudo systemctl enable ai-search-embedding
sudo systemctl start ai-search-embedding
sudo systemctl status ai-search-embedding

journalctl -u ai-search-backend -f

docker stats

df -h

nvidia-smi

docker exec ai_search_postgres pg_dump -U ai_search ai_search > ai_search_backup.sql

cat ai_search_backup.sql | docker exec -i ai_search_postgres psql -U ai_search -d ai_search

tar -czvf ai_search_data_backup.tar.gz ~/enterprise-ai-search/data

curl http://localhost:9200/_cat/indices?v

curl -X DELETE http://localhost:9200/enterprise_ai_search

docker compose ps
docker logs ai_search_milvus --tail=100

lsof -i:19530

FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=1024)

FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=768)

curl http://localhost:9200

curl http://localhost:9200/_cat/indices?v