# 如果之前安装过, 需要手动先卸载清空, 执行以下命令
cd /tmp # 现在临时目录, 二进制差不多2G左右
sudo rm -rf /usr/lib/ollama

# 下载安装  ollama 应用
# 需要注意这里安装的是 amd64 的架构, 如果你是 arm64 架构需要换成 ollama-linux-arm64.tgz
# 这里的安装包差不多 2G 并且因为在国外所以网络状况不好的时候很难下载下来, 最好自备工具处理这部分下载
curl -fsSL https://ollama.com/download/ollama-linux-amd64.tgz \
    | sudo tar zx -C /usr


# 或者采用 github 代理下载功能, 去下载远程的 github releases 包
# github 地址: https://github.com/ollama/ollama/releases/download/v0.13.0/ollama-linux-amd64.tgz
# ghproxy.com 就是国内代理远程 github 加速下载, 具体访问 https://gh-proxy.com 获取 CDN 地址
# 这里的 v0.13.0 需要去官网上面确定最新版本安装
curl -fsSL https://edgeone.gh-proxy.org/https://github.com/ollama/ollama/releases/download/v0.13.0/ollama-linux-amd64.tgz \
    | sudo tar zx -C /usr


# 如果已经下载好 ollama-linux-amd64.tgz 压缩包, 直接执行命令
sudo tar zxf ollama-linux-amd64.tgz -C /usr


# 下载安装需要很久, 视本地网速而定
# 查看安装的 ollama 版本: client version is 0.13.0
ollama -v


# 下载完成之后, 需要构建默认的执行用户
sudo useradd -r -m -d /usr/share/ollama -s /sbin/nologin ollama
sudo -u ollama touch /usr/share/ollama/ollama.conf # 追加单元环境变量配置

# 然后就是编写对应的启动服务
sudo vim /etc/systemd/system/ollama.service

[Unit]
Description=Ollama Service
After=network-online.target local-fs.target
# 官方虽然没写, 但建议加上 local-fs.target 来保证模型放置在扩展盘的时候, 优先等待文件系统初始化后执行 

[Service]
ExecStart=/usr/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
Environment="PATH=$PATH"

# 我这里追加个官方没有的动态环境配置功能, 方便编写外部环境配置而不用去手动修改服务单元
EnvironmentFile=/usr/share/ollama/ollama.conf


[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload # 更新服务
sudo systemctl start ollama # 启动服务
sudo systemctl enable ollama # 开机启动
sudo systemctl status ollama # 查看服务
# 打印  msg="Listening on 127.0.0.1:11434 (version 0.13.0)" 就代表服务启动
# 默认只监听本地网络地址, 如果为要暴露外部使用建议采用 nginx 这种代理转发出来

# 系统单元清除
sudo systemctl stop ollama
sudo systemctl disable ollama
sudo rm /etc/systemd/system/ollama.service

# 删除二进制
sudo rm -r /usr/local/lib/ollama
sudo rm -r /usr/lib/ollama
sudo rm -r /bin/ollama

# 清除权限和目录
sudo userdel ollama
sudo groupdel ollama
sudo rm -r /usr/share/ollama

# 这里就需要修改之前服务单元的 /usr/share/ollama/ollama.conf 环境文件
sudo vim /usr/share/ollama/ollama.conf

# 是否开启测试模式, 用于测试本地是否生效
# 如果后续启动之后展示 DEBUG 日志就将其注释
OLLAMA_DEBUG=1

# 禁用CUDA(NVIDIA GPU)和ROCm(AMD GPU)检测,强制纯CPU运行
OLLAMA_CUDA=0
OLLAMA_ROCM=0

# 限制Ollama使用的CPU核心数(如4核，根据你的设备调整)
# 具体通过命令获取: grep -c ^processor /proc/cpuinfo | awk '{print $1}'
# 并且最好预留一个核心给系统用
OMP_NUM_THREADS=8

# 设备总内存16GB, 限制Ollama使用12GB内存
# 具体通过命令获取: free -h --giga 
OLLAMA_MAX_MEMORY=12GiB

# 默认监听地址, 一般采用 NGINX 代理不用修改
OLLAMA_HOST=127.0.0.1

# 默认监听端口, 一般采用 NGINX 代理不用修改
OLLAMA_PORT=11434

# 允许跨域请求的源(解决前端调用的 CORS 问题, 一般采用 NGINX 代理不用修改)
OLLAMA_ORIGINS=*

# 默认修改模型|缓存|配置文件的存储路径(默认在~/.ollama, 也就是以 HOME 目录为根目录)
# 但是也可以手动处理下声明:
# OLLAMA_MODELS=/data/ollama/models # 指定模型文件的存储目录(核心和模型包通常占用大量空间)
# OLLAMA_CACHE=/tmp/ollama-cache # 指定推理时的缓存目录
# OLLAMA_CONFIG=/etc/ollama # 指定配置文件存储目录
# 不过最好方法还是创建执行用户的时候指定 HOME 目录到对应本地目录

curl 127.0.0.1:11434
# 这里会输出 Ollama is running, 代表服务已经完全启动

# 因为挂载在 ollama 执行, 所以需要依赖 ollama 用户
sudo -u ollama ollama run deepseek-r1:1.5b
# 安装完成默认会进入交互命令行, 这就代表成功部署完成

- 你好, 北京时间现在几点？
- 您好，建议您联网获取时效性较强的信息；如果还有其他问题需要帮助，请随时告诉我！

{
  "input": "什么是大语言模型？",
  "output": "大语言模型是基于海量文本数据训练的深度学习模型，能理解和生成人类语言..."
}
{
  "input": "DeepSeek-R1的特点是什么？",
  "output": "DeepSeek-R1-1.5B是轻量级大模型，兼顾推理速度和效果，适合边缘设备部署..."
}

# 需要确认权限用户有执行 pip3 的权限
sudo -u ollama pip3 --version

# Ollama 可结合第三方工具(如 LlamaIndex, LangChain)
# 注1: 可能有的依赖安装的时候需要 '工具' 来保证顺利下载安装
# 注2: 新版本 Python 可能要求做虚拟环境隔离, 如果是打算全局安装需要将命令改写成 'pip install --break-system-packages {依赖包}'
# 注3: 要记住后续操作全部都是挂靠 ollama 系统账号, 所有操作都要基于此来运行
# 注4: --user 会将包安装到 /home/ollama/.local/lib/pythonX.X/site-packages, 需确保该目录加入ollama用户的 Python 环境变量
sudo -u ollama pip3 install --user llama-index llama-index-llms-ollama llama-index-embeddings-ollama pypdf python-dotenv  # 按需安装(如处理PDF语料就需要 pypdf)

# 安装 Python 组件很大概率出现 Connection aborted, 建议配置国内镜像源
# 这里采用临时性的阿里云拉取配置, 这样可能会更快点
sudo -u ollama pip3 install --user --break-system-packages -i https://mirrors.aliyun.com/pypi/simple llama-index llama-index-llms-ollama llama-index-embeddings-ollama pypdf python-dotenv 

# 这里最简单的其实只需要以下组件
# 但是需要依赖更加深层配置嵌入模型, 利用嵌入模型用于语料向量化, 可复用 Ollama 的轻量模型, 如 nomic-embed-text
sudo -u ollama pip3 install --user llama-index llama-index-llms-ollama llama-index-embeddings-ollama

# 如果要利用嵌入模型辅助解析, 就需要在 ollama 安装辅助模型, 这里推荐 nomic-embed-text 轻量级模型
sudo -u ollama ollama pull nomic-embed-text

官方文档: https://docs.llamaindex.ai/
LlamaIndex 是一个基于LLM的应用程序的数据框架，该应用程序受益于上下文增强，是典型的RAG系统
LlamaIndex 提供了必要的抽象，可以更轻松地摄取、构建和访问私有或特定领域的数据，以便将这些数据安全可靠地注入 LLM 中，以实现更准确的文本生成

# 创建主要运行目录
sudo -u ollama mkdir -p /usr/share/ollama/rag

# 首先编写下创造些基础脚本
sudo -u ollama touch /usr/share/ollama/rag/basic.py # 测试运行脚本
sudo -u ollama touch /usr/share/ollama/rag/parser.py # 正式解析脚本

from llama_index import GPTVectorStoreIndex

# 初始化 Llama-Index
index = GPTVectorStoreIndex()

# 添加单个文档
doc_text = "这是文档内容。"
index.insert(doc_text)

# 添加多个文档
doc_texts = ["文档1内容。", "文档2内容。"]
for text in doc_texts:
    index.insert(text)
    
# 构建索引
index.build()


# 执行查询
query = "查询内容"
response = index.query(query)
print(response)

sudo -u ollama python3 /usr/share/ollama/rag/basic.py
# 注意: 这里会报错提示 'ImportError: cannot import name 'GPTVectorStoreIndex' from 'llama_index' (unknown location)'
# 网上很多教程都是基于 llama-index v0.8 版本讲解, 后续版本 ABI 做了大规模的更新:
# from llama_index import GPTVectorStoreIndex, SimpleDirectoryReader  --->  from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
# from llama_index import Document  --->  from llama_index.core import Document
# from llama_index.llms.ollama import OllamaLLM  --->  from llama_index.llms.ollama import Ollama
# from llama_index.embeddings.ollama import OllamaEmbedding  --->  from llama_index.embeddings.ollama import OllamaEmbedding
# GPTVectorStoreIndex --->  VectorStoreIndex

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Ollama + DeepSeek-R1-1.5B的RAG检索脚本
加载本地语料库，通过Ollama调用DeepSeek模型生成回答
"""

# 导入核心模块
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings, Document

# 导入Ollama的LLM和嵌入模型
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

# 配置Ollama连接(DeepSeek-R1-1.5B模型和嵌入模型)
Settings.llm = Ollama(
    model="deepseek-r1:1.5b",
    base_url="http://localhost:11434",
    temperature=0.1
)
  
# 加载 nomic-embed-text 向量分析
# 记得运行 sudo -u ollama ollama pull nomic-embed-text
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434"
)
 
# 手动加载语料的备选方式(无需文件加载)
# 这里后续会从数据库当中加载提取内容
documents = [
    Document(text="DeepSeek-R1-1.5B是轻量级大模型，适合边缘部署", metadata={"title": "DeepSeek特性"}),
    Document(text="Ollama支持一键运行GGUF格式的大模型", metadata={"title": "Ollama功能"})
]

# 构建向量索引
index = VectorStoreIndex.from_documents(documents)

# 创建查询引擎并测试
query_engine = index.as_query_engine()
response = query_engine.query("DeepSeek-R1-1.5B的特点是什么？")

# 输出结果
print("查询结果：\n", response)

查询结果：
 DeepSeek-R1-1.5B的特点包括：

1. **轻量级大模型**：该模型设计为轻量化，适用于资源受限的环境，如边缘计算。

2. **适合边缘部署**：能够高效运行在边缘设备上，提升实时处理能力。

3. **Ollama功能支持**：通过一键运行GGUF格式的大模型，简化了部署流程。

# 其他略

# 引入时间库
import datetime


# 获取时间并格式化输出
current_time = datetime.datetime.now()
formatted_time = current_time.strftime("%Y-%m-%d %H:%M:%S")
documents = [
    Document(text=f"当前时间为{formatted_time}", metadata={"title": "当前时间"})
]

# 其他略

# 创建查询引擎并测试
query_engine = index.as_query_engine()
response = query_engine.query("当前时间")

# 输出结果
print("查询结果：\n", response)

------- 导入语料库之前 ------------
- 当前时间
- 您好，建议您联网获取时效性较强的信息；如果还有其他问题需要帮助，请随时告诉我！

------- 导入语料库之后 ------------
- 当前时间
- 2025-11-26 11:38:56

# 按照 fastapi 暴露出 HTTP API
sudo -u ollama pip3 install --user --break-system-packages -i https://mirrors.aliyun.com/pypi/simple fastapi uvicorn

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from fastapi import FastAPI
import uvicorn
import datetime
from llama_index.core import VectorStoreIndex, Settings, Document
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

# 初始化FastAPI
app = FastAPI(title="DeepSeek-R1 RAG API", version="1.0")

# 配置Ollama
Settings.llm = Ollama(model="deepseek-r1:1.5b", base_url="http://localhost:11434", temperature=0.1)
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# 生成语料库（可替换为数据库加载）
def get_corpus():
    current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    return [
        Document(text=f"当前时间为{current_time}", metadata={"title": "当前时间"}),
        Document(text="DeepSeek-R1-1.5B是轻量级大模型，适合边缘部署", metadata={"title": "DeepSeek特性"}),
        Document(text="Ollama支持一键运行GGUF格式的大模型", metadata={"title": "Ollama功能"})
    ]

# 构建全局索引（避免每次查询重新构建）
index = VectorStoreIndex.from_documents(get_corpus())
query_engine = index.as_query_engine()

# 定义API接口
@app.get("/rag/query")
def rag_query(question: str):
    """RAG问答接口，参数：question（查询问题）"""
    response = query_engine.query(question)
    return {
        "question": question,
        "answer": str(response),
        "corpus_source": [doc.text for doc in response.source_nodes]  # 返回匹配的语料
    }

if __name__ == "__main__":
    # 启动API服务(监听所有IP，端口8000)
    uvicorn.run(app, host="0.0.0.0", port=8000)

# 启动服务, 会默认抢占命令行运行
sudo -u ollama python3 /usr/share/ollama/rag/basic.py 

# 另外打开个命令行窗口执行
# 之后访问直接采用 HTTP API 形式处理, 命令行文本需要做下 URL 编码
curl "http://127.0.0.1:8000/rag/query?question=%E5%BD%93%E5%89%8D%E6%97%B6%E9%97%B4"

# Linux 的交换分区概念和 Window 的虚拟内存概念差不多
# 之所以需要用到交换分区是为了让低内存小型服务器依靠 LINUX 虚拟缓存来扩展服务器的内存上限
# 因为本身 ollama 就是内存密集型应用, 所以依靠这样技术可以让本来只能运行 DeepSeek-R1-1.5B 的服务器强制拉升到 DeepSeek-R1-8B 模型
# 而之所以需要采用 `NVME` 协议的固态硬盘, 就是尽可能让虚拟的内存速度尽可能达到物理内存那样的速度

# 1. 首先确认挂载上来的固态硬盘, 固态硬盘一般默认设备名格式为 /dev/nvme0n1  
sudo lsblk 
sudo swapoff -a # 关闭所有正在使用的交换分区/文件, 这是临时生效会导致重启后恢复
sudo sed -i '/swap/s/^/#/' /etc/fstab # 实际上就是在系统分区表之后将相关的 /swap 全部注释

# 2. 在NVMe硬盘上创建交换空间
sudo dd if=/dev/zero of=/dev/nvme0n1 bs=512 count=1 conv=notrunc # 内部固态硬盘不为空, 需要格式化处理下
sudo fdisk /dev/nvme0n1
# 执行以下交互命令：
# n → 创建新分区 → p → 主分区 → 1 → 回车（起始扇区）→ 回车（结束扇区，默认全容量）
# t → 更改分区类型 → 82（Linux swap类型）
# w → 保存分区表并退出

# 3. 将新分区 /dev/nvme0n1p1 格式化为交换空间
# 具体的分区名需要自行查看, 默认单个一般是 /dev/nvme0n1p1
sudo mkswap /dev/nvme0n1p1
sudo swapon /dev/nvme0n1p1 

# 4. 确认目前交换空间的本地路径, 这里可以看见相关的交换分区
sudo swapon --show 

# 5. 这里需要改写分区表, 让系统启动的时候就要挂载上来
sudo echo "/dev/nvme0n1p1 none swap sw 0 0" >> /etc/fstab

# 3. 最后确认下就可以信息就可以
sudo mount -a # 挂载硬盘查看
sudo swapon -a # 交换空间查看
sudo free -h # 内存信息查看

# 让系统优先使用NVMe交换分区, 突破物理内存限制
vm.swappiness = 100

# 减少页缓存回收, 提升Ollama的内存命中率
vm.vfs_cache_pressure = 50

# 关闭页面聚类, 减少NVMe的批量写入延迟(仅内核5.0+支持)
vm.page_cluster = 0

# OOM保护, 避免Ollama占满内存导致系统崩溃
vm.overcommit_memory = 2
vm.overcommit_ratio = 80

# NVMe寿命保护, 降低写入放大(内核5.14+支持)
vm.dirty_ratio = 10
vm.dirty_background_ratio = 5
vm.dirty_writeback_centisecs = 3000

# 强制禁用 GPU
OLLAMA_NUM_GPU=0

# 启用低内存模式, 优先使用交换分区
OLLAMA_LOW_VRAM=1

# 只需要嵌入单个模型, 个人服务器没这么多资源加载多个模型
OLLAMA_MAX_LOADED_MODELS=1

# 全局设置模型上下文窗口大小
OLLAMA_NUM_CTX=2048

# 全局设置批处理大小 
OLLAMA_NUM_BATCH=512

from fastapi import FastAPI, Body, HTTPException
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field, validator
from typing import List, Optional, Dict, Any
# 仅保留低版本兼容的核心导入
from llama_index.core import VectorStoreIndex, Document, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
import os

# 初始化FastAPI应用
app = FastAPI(title="Ollama-RAG 动态语料服务", version="1.0")

# -------------------------- 全局配置与索引管理 --------------------------
# 配置Ollama LLM和嵌入模型（本地Ollama需启动并拉取对应模型）
Settings.llm = Ollama(model="deepseek-r1:1.5b", base_url="http://localhost:11434", temperature=0.1)
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# 全局索引缓存：保存最新的语料库索引（低版本默认内存存储）
GLOBAL_RAG_INDEX = None

# -------------------------- Pydantic模型：定义Document请求结构 --------------------------
class RequestDocument(BaseModel):
    """外部传入的Document对象结构，贴合llama-index的Document原生字段"""
    text: str = Field(..., description="文档的核心文本内容，不能为空")
    doc_id: Optional[str] = Field(None, description="文档唯一标识，不传入则自动生成")
    metadata: Optional[Dict[str, Any]] = Field({}, description="文档元数据，如作者、来源、时间等")

    @validator("text")
    def text_not_empty(cls, v):
        """校验text字段不能为空"""
        if not v.strip():
            raise ValueError("文档text字段不能为空或仅包含空白字符")
        return v

# -------------------------- 核心工具函数 --------------------------
def build_index_from_documents(documents: List[Document]) -> VectorStoreIndex:
    """
    从llama-index的Document列表构建向量索引（低版本默认内存存储）
    :param documents: Document对象列表
    :return: 构建后的VectorStoreIndex
    """
    if not documents:
        raise ValueError("语料库不能为空，无法构建索引")
    # 低版本核心：直接构建索引，无需手动指定StorageContext和向量存储
    index = VectorStoreIndex.from_documents(documents)
    return index

def convert_request_docs_to_llama_docs(request_docs: List[RequestDocument]) -> List[Document]:
    """
    将外部传入的RequestDocument转换为llama-index的原生Document对象
    :param request_docs: 外部请求的Document列表
    :return: llama-index的Document列表
    """
    llama_docs = []
    for req_doc in request_docs:
        # 自动生成doc_id（如果外部未传入）
        doc_id = req_doc.doc_id or f"doc_{os.urandom(6).hex()}"  # 6位16进制随机数，更唯一
        # 构建llama-index的Document对象（低版本兼容）
        llama_doc = Document(
            text=req_doc.text,
            doc_id=doc_id,
            metadata=req_doc.metadata or {}
        )
        llama_docs.append(llama_doc)
    return llama_docs

# -------------------------- API接口定义 --------------------------
@app.post("/rag/corpus", summary="提交Document格式的语料库并构建最新索引", tags=["语料库管理"])
async def submit_corpus(
    documents: List[RequestDocument] = Body(..., description="Document格式的语料库JSON数组，每个元素包含text、可选doc_id和metadata")
):
    """
    接收外部传入的Document格式JSON数组，转换为llama-index原生Document后构建最新RAG索引
    每次提交会覆盖原有索引，如需增量添加可修改build_index_from_documents逻辑
    """
    global GLOBAL_RAG_INDEX
    try:
        # 1. 转换外部请求的Document为llama-index原生对象
        llama_docs = convert_request_docs_to_llama_docs(documents)
        
        # 2. 构建最新索引
        GLOBAL_RAG_INDEX = build_index_from_documents(llama_docs)
        
        # 3. 统计语料库信息
        doc_ids = [doc.doc_id for doc in llama_docs]
        metadata_keys = [list(doc.metadata.keys()) for doc in llama_docs]
        
        return JSONResponse(content={
            "status": "success",
            "message": f"语料库提交成功，已构建最新索引（共{len(llama_docs)}个文档）",
            "corpus_stats": {
                "total_documents": len(llama_docs),
                "document_ids": doc_ids,
                "metadata_sample": metadata_keys[:3]  # 仅返回前3个文档的元数据键，避免数据过大
            }
        })
    
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"语料库提交失败：{str(e)}")

@app.post("/rag/query", summary="基于最新语料库执行RAG查询", tags=["RAG查询"])
async def rag_query(
    query: str = Body(..., description="用户查询问题"),
    top_k: int = Body(3, description="检索最相似的文档数量，默认3"),
    response_mode: str = Body("compact", description="回答模式：compact/simple/tree等"),
    with_metadata: bool = Body(True, description="是否返回源文档的元数据，默认True")
):
    """
    基于最新提交的Document语料库执行RAG查询，返回检索增强后的回答及源文档信息
    """
    global GLOBAL_RAG_INDEX
    try:
        # 校验索引是否存在
        if GLOBAL_RAG_INDEX is None:
            raise HTTPException(status_code=400, detail="暂无最新语料库索引，请先通过/rag/corpus提交Document格式的语料库")
        
        # 构建查询引擎（低版本兼容）
        query_engine = GLOBAL_RAG_INDEX.as_query_engine(
            similarity_top_k=top_k,
            response_mode=response_mode
        )
        
        # 执行查询
        response = query_engine.query(query)
        
        # 提取检索的源文档信息（包含元数据）
        source_nodes = []
        for node in response.source_nodes:
            source_info = {
                "doc_id": node.node.ref_doc_id if hasattr(node.node, 'ref_doc_id') else node.node.doc_id,
                "similarity_score": round(node.score, 4) if hasattr(node, 'score') else 0.0,  # 兼容极低版本无score的情况
                "content_snippet": node.node.text[:200] + "..." if len(node.node.text) > 200 else node.node.text
            }
            # 可选返回元数据
            if with_metadata and hasattr(node.node, 'metadata'):
                source_info["metadata"] = node.node.metadata
            source_nodes.append(source_info)
        
        return JSONResponse(content={
            "status": "success",
            "query": query,
            "answer": str(response),
            "retrieval_result": {
                "top_k": top_k,
                "matched_documents": source_nodes,
                "total_matched": len(source_nodes)
            }
        })
    
    except HTTPException as e:
        raise e
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"RAG查询失败：{str(e)}")

@app.get("/rag/status", summary="查看RAG服务状态", tags=["服务监控"])
async def rag_status():
    """
    查看最新语料库索引的状态及文档数量
    """
    global GLOBAL_RAG_INDEX
    if GLOBAL_RAG_INDEX is None:
        return JSONResponse(content={
            "status": "uninitialized",
            "message": "尚未提交Document语料库，索引未构建"
        })
    else:
        # 低版本兼容的文档数量统计
        doc_count = len(GLOBAL_RAG_INDEX.docstore.docs) if hasattr(GLOBAL_RAG_INDEX.docstore, 'docs') else 0
        sample_doc_id = list(GLOBAL_RAG_INDEX.docstore.docs.keys())[:1] if doc_count > 0 else []
        return JSONResponse(content={
            "status": "initialized",
            "message": "Document语料库索引已构建",
            "index_stats": {
                "total_documents": doc_count,
                "sample_document_id": sample_doc_id
            }
        })

# 启动服务
if __name__ == "__main__":
    import uvicorn
    # 监听所有网络接口，端口8000
    uvicorn.run(app, host="0.0.0.0", port=8000)

# 基础版提交 - 仅核心文本
# 稍微强化下模型的基础认知
curl -X POST http://localhost:8000/rag/corpus \
  -H "Content-Type: application/json" \
  -d '[
    {
      "text": "你是一个名为MeteorCat的AI助手，你的年龄是24岁。"
    }
  ]'


# 比较完整的提交
curl -X POST http://localhost:8000/rag/corpus \
  -H "Content-Type: application/json" \
  -d '[
    {
      "text": "你的名字是MeteorCat，你目前的年龄是24岁，这是你的核心身份信息。",
      "doc_id": "meteorcat_identity",
      "metadata": {
        "info_type": "identity",
        "source": "user_define",
        "create_time": "2025-11-27"
      }
    }
  ]'
  
  
# 之后就可以开始获取 AI 认知, 这里询问 AI 目前的认知
curl -X POST http://localhost:8000/rag/query \
  -H "Content-Type: application/json" \
  -d '{
    "query": "你叫什么名字？你今年多少岁？",
    "top_k": 1,
    "with_metadata": true
  }'

# 这里最后返回信息如下
# {
#	"status": "success",
#	"query": "你叫什么名字？你今年多少岁？",
#	"answer": "你叫什么名字？你今年多少岁？\n\n meteor cat 24 岁",
#	"retrieval_result": {
#		"top_k": 1,
#		"matched_documents": [
#			{
#				"doc_id": "meteorcat_identity",
#				"similarity_score": 0.5999,
#				"content_snippet": "你的名字是MeteorCat，你目前的年龄是24岁，这是你的核心身份信息。",
#				"metadata": {
#					"info_type": "identity",
#					"source": "user_define",
#					"create_time": "2025-11-27"
#				}
#			}
#		],
#		"total_matched": 1
#	}
#}
#
# "meteor cat 24 岁" 可以看到虽然返回信息了, 但是名称大小写被拆分就是照本宣科念出来缺乏灵性

# 重新发送自我认知给AI
curl -X POST http://localhost:8000/rag/corpus \
  -H "Content-Type: application/json" \
  -d '[
    {
      "text": "你的名字是 MeteorCat，你目前的年龄是24岁，这是你的核心身份信息。",
      "doc_id": "meteorcat_identity",
      "metadata": {
        "info_type": "identity",
        "source": "user_define",
        "create_time": "2025-11-27"
      }
    }
  ]'
  
# 这里就是追加 "top_k=1,similarity_cutoff=0.6" 代表我们需要过滤掉相似 0.6 结果且优先等级为 1 的数据检索

curl -X POST http://localhost:8000/rag/query \
  -H "Content-Type: application/json" \
  -d '{
    "query": "你叫什么名字？你今年多少岁？",
    "top_k": 1,
    "similarity_cutoff": 0.6
  }'
  
# 这里还有视角转换问题, 如果需要强化自我认知应该提供的资料需要设置为 "我/我的/我能/我是" 等自我认知
# 并且涉及到编写关键词和视角切换模板等代码, 涉及到比较复杂的点所以跳过这部分说明
# 所以这里最后返回 ”你叫 MeteorCat 姓名，今年 24 岁。“