尝试 qdrant 向量搜索~



## 部署向量服务
在 raspberry pi 使用 docker 部署
- 向量数据库：qdrant
- 向量化服务：m3e
    - M3E主要针对中文文本进行向量化处理，但也有一定的双语处理能力
    - M3E属于小模型，资源使用不高，CPU也可以运行，适合私有化部署和资源受限的环境。
```yml
version: '2'
services:
  qdrant:
    image: qdrant/qdrant:v1.13.0
    ports:
      - "6333:6333"
      - "6334:6334"
    volumes:
      - "/disk/app/qdrant:/qdrant/storage"
    restart: on-failure

  m3e_api:
    container_name: m3e_api
    environment:
      TZ: Asia/Shanghai
      sk-key: 'sk-42tr'
    image: docker.io/gaord/m3e-large-api:231129
    restart: always
    ports:
      - "6200:6008"
```

## 使用
### 调用向量化 api
```shell
curl --location --request POST 'http://localhost:6200/v1/embeddings' --header 'Authorization: Bearer sk-42tr' --header 'Content-Type: application/json' --data-raw '{
  "model": "m3e",
  "input": ["laf是什么"]
}'
```
问题：使用 树莓派 4b cpu 跑起来太慢了，以上调用就要花 6s 多，一个段落就要 1min，后续尝试部署到带 gpu/npu 的设备。


### 使用 qdrant
使用 rust client，当前代码中未使用向量化服务生成的结果

**Cargo.toml**
```
[package]
name = "test-qdrant"
version = "0.1.0"
edition = "2024"

[dependencies]
anyhow = "1.0.97"
qdrant-client = "1.13.0"
serde_json = "1.0.140"
tokio = { version = "1.44.2", features = ["rt-multi-thread"] }
tonic = "0.13.0"
once_cell = "1.19.0"
uuid = { version = "1", features = ["v4"] }
```
**qd.rs**
```rust
use once_cell::sync::Lazy;
use qdrant_client::qdrant::r#match::MatchValue;
use qdrant_client::qdrant::{
    Condition, CreateCollectionBuilder, Distance, Filter, PointStruct, ScalarQuantizationBuilder,
    SearchParamsBuilder, SearchPointsBuilder, UpsertPointsBuilder, Value, VectorParamsBuilder,
};
use qdrant_client::{Payload, Qdrant};

use std::collections::HashMap;
use std::sync::Arc;
use uuid::Uuid;

static COLLECTION_NAME: &str = "x";
static CLIENT: Lazy<Arc<Qdrant>> = Lazy::new(|| {
    let client = Qdrant::from_url("http://192.168.1.3:6334")
        .build()
        .expect("Failed to build Qdrant client");
    Arc::new(client)
});

pub async fn init() -> anyhow::Result<()> {
    CLIENT.delete_collection(COLLECTION_NAME).await?;
    CLIENT
        .create_collection(
            CreateCollectionBuilder::new(COLLECTION_NAME)
                .vectors_config(VectorParamsBuilder::new(10, Distance::Cosine))
                .quantization_config(ScalarQuantizationBuilder::default()),
        )
        .await?;

    let collection_info = CLIENT.collection_info(COLLECTION_NAME).await?;
    dbg!(collection_info);
    Ok(())
}

pub async fn add_points(payloads: Vec<Payload>) -> anyhow::Result<()> {
    let points: Vec<PointStruct> = payloads
        .into_iter()
        .map(|payload| PointStruct::new(Uuid::new_v4().to_string(), vec![12.; 10], payload))
        .collect();
    CLIENT
        .upsert_points(UpsertPointsBuilder::new(COLLECTION_NAME, points))
        .await?;
    Ok(())
}

pub async fn search(
    field: impl Into<String>,
    r#match: impl Into<MatchValue>,
) -> anyhow::Result<Vec<HashMap<String, Value>>> {
    let response = CLIENT
        .search_points(
            SearchPointsBuilder::new(COLLECTION_NAME, [12.; 10], 10)
                .filter(Filter::all([Condition::matches(field, r#match)]))
                .with_payload(true)
                .params(SearchParamsBuilder::default().exact(true)),
        )
        .await?;
    let payloads: Vec<HashMap<String, Value>> = response
        .result
        .into_iter()
        .map(|point| point.payload)
        .collect();
    Ok(payloads)
}
```
**main.rs**
```rust
use qdrant_client::Payload;
mod qd;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    qd::init().await?;
    let payload1: Payload = serde_json::json!(
        {
            "title": "为什么奥特曼不直接放大招打怪兽",
            "content": "奥特曼的技能是打怪兽，而不是放大招。"
        }
    )
    .try_into()
    .unwrap();
    let payload2: Payload = serde_json::json!(
        {
            "title": "同样是带小孩，二哈是二哈，边牧是边牧",
            "content": "二哈是二哈，边牧是边牧，它们都是可爱的宠物。"
        }
    )
    .try_into()
    .unwrap();

    qd::add_points(vec![payload1, payload2]).await?;
    let payloads = qd::search("title", "奥特曼".to_string()).await?;
    println!("{:?}", payloads);

    Ok(())
}
```

## 参考
- [【接入 M3E 向量模型】](https://doc.tryfastgpt.ai/docs/development/custom-models/m3e/)
- [qdrant rust-client](https://github.com/qdrant/rust-client)

rust 向量搜索

尝试使用 Leptos 进行全栈开发~





## 步骤
- `cargo install cargo-leptos`
  
  报错：`fatal error: "algorithm" file not found`

  解决：重装 xcode
  ```shell
  sudo rm -rf /Library/Developer/CommandLineTools
  Xcode-select --install
  ```
- `rustup target add wasm32-unknown-unknown`
- `cargo leptos new --git leptos-rs/start`

  use the Leptos starter template - it comes preconfigured with all these ready from you
  
- `cargo leptos watch`

  build frontend to wasm, compile backend and start it.
  
  报错：
  ```
  it looks like the Rust project used to create this Wasm file was linked against
      version of wasm-bindgen that uses a different bindgen format than this binary:

        rust Wasm file schema version: 0.2.95
           this binary schema version: 0.2.100
  ```
  解决：更新 `Cargo.toml` 中的 `wasm-bindgen` 版本 `wasm-bindgen = "=0.2.95"` 改为 `wasm-bindgen = "=0.2.100"`，然后执行 `cargo update`
  
项目成功启动，默认使用的 actix，不想用，换 axum。

### 使用 axum
- `cargo install cargo-leptos`
- `cargo leptos new --git leptos-rs/start-axum`
- `cd your_project_dir`
- `rustup toolchain install nightly`
- `rustup target add wasm32-unknown-unknown`
- `cargo leptos watch`

### 添加 tailwind
- `npm install tailwindcss`
- Create the file `style/tailwind.css`
  ```css
  @import "tailwindcss";
  ```
- Update `Cargo.toml`
  ```toml
  # IMPORTANT! Remove or comment-out
  # style-file = "style/main.scss"

  # Activates the tailwind build
  tailwind-input-file = "style/tailwind.css"
  ```
- Update `src/app.rs` to use tailwind.

## 编译
`cargo leptos build -r`

## 交叉编译
- 安装编译目标：`rustup target add aarch64-unknown-linux-gnu`
- 安装交叉编译工具链：`brew tap messense/macos-cross-toolchains` + `brew install aarch64-unknown-linux-gnu`（可能不需要）
- 创建 `.cargo/config.toml`
  ```toml
  [target.aarch64-unknown-linux-gnu]
  linker = "aarch64-unknown-linux-gnu-gcc"
  ```
- 编译 `LEPTOS_BIN_TARGET_TRIPLE=aarch64-unknown-linux-gnu cargo leptos build --release`

## 启动
拷贝到服务器
- `x-leptos-axum`
- `site/`

执行
```shell
export LEPTOS_OUTPUT_NAME="x-leptos-axum"
export LEPTOS_SITE_ROOT="site"
export LEPTOS_SITE_PKG_DIR="pkg"
export LEPTOS_SITE_ADDR="0.0.0.0:3000"
export LEPTOS_RELOAD_PORT="3001"
./x-leptos-axum
```

leptos 全栈开发

python 生成 docx，以及 html 转 docx，使用 docx 库~




## 注意点
- docx 文档携带的样式表不同，存在时直接配置 style 即可，不存在则要使用 `doc.styles.add_style(style, 1)` 配置
- `run.font.name = fontname` 修改中文字体可能无效（测试时发现标题的字体修改失败），因为 docx 只修改 latin 字体，但 eastAsia 才控制中文 `run._element.rPr.rFonts.set(qn("w:eastAsia"), fontname)`

## 关键代码
```python
class HTMLRequest(BaseModel):
    html: str
    type: Optional[str] = None
    template_id: Optional[str] = None

@router.post("/gen_template")
async def gen_template(request: HTMLRequest, bgtasks: BackgroundTasks):
    """
    制式输出
    """
    date_str = datetime.now().strftime("%Y%m%d_%H%M%S")
    output_filename = f"{date_str}_{str(uuid.uuid4())[:8]}.docx"
    output_path = os.path.join(STATIC_DIR, output_filename)

    if request.template_id is None:
        await gen_doc_without_template(request.html, output_path)
    else:
        await gen_doc_with_template(request.html, request.template_id, output_path)

    filename = output_filename
    filepath = output_path
    if request.type is not None and request.type == "wps":
        filepath = convert_docx_to_wps(output_path)
        filename = filename.replace(".docx", ".wps")
    elif request.type is not None and request.type == "pdf":
        filepath = convert_docx_to_pdf(output_path)
        filename = filename.replace(".docx", ".pdf")

    # 添加后台任务，返回文件后自动删除
    bgtasks.add_task(cleanup_file, output_path)
    if filepath != output_path:
        bgtasks.add_task(cleanup_file, filepath)
    return FileResponse(
        path = filepath,
        media_type = 'application/octet-stream',
        filename = filename,
        headers = {
            'Content-Disposition': f'attachment; filename="{quote(filename)}"'
        }
    )

FONT_NAME = {'h1': 'SimHei', 'h2': '楷体', 'h3': '仿宋', 'h4': '仿宋', 'p': '仿宋'}
FONT_SIZE = Pt(16)


# 首行缩进
def add_indent(paragraph, indent_chars=2):
    pPr = paragraph._element.get_or_add_pPr()
    ind = OxmlElement('w:ind')
    ind.set(qn("w:firstLine"), str(indent_chars * 300))  # 1个中文字符约300单位
    pPr.append(ind)

# 根据模板以及 html 生成 docx
async def gen_doc_with_template(html: str, template_id: str, output_path: str):
    template = Templates.get_template_by_id(template_id)
    if template is None:
        return
    filename = template.template_path.split("/")[-1]
    template_path = os.path.join(TEMPLATE_DIR, filename)
    doc = Document(template_path)
    available_styles = [s.name for s in doc.styles]
    for paragraph in doc.paragraphs:
        if "content" in paragraph.text:
            paragraph.clear()
            soup = BeautifulSoup(html, 'html.parser')
            def recursive_parse(element, paragraph):
                for child in element.children:
                    if not child.name:
                        continue
                    if child.name.startswith('h') and child.name[1:].isdigit():
                        heading = paragraph.insert_paragraph_before(child.get_text())
                        style = "Heading %s" % child.name[1:]
                        if style in available_styles:
                            heading.style = style
                        else:
                            heading.style = doc.styles.add_style(style, 1)
                        for run in heading.runs:
                            run.font.size = FONT_SIZE
                            run.font.name = FONT_NAME[child.name]
                            # 直接用 run.font.name = fontname 可能无效，因为 docx 只修改 latin 字体，但 eastAsia 才控制中文
                            run._element.rPr.rFonts.set(qn("w:eastAsia"), FONT_NAME[child.name])
                            run.font.color.rgb = RGBColor(0, 0, 0)
                            run.font.italic = False
                    elif child.name == 'p':
                        para = paragraph.insert_paragraph_before(child.get_text())
                        for run in para.runs:
                            run.font.size = FONT_SIZE
                            run.font.name = FONT_NAME[child.name]
                            run._element.rPr.rFonts.set(qn("w:eastAsia"), FONT_NAME[child.name])
                            run.font.color.rgb = RGBColor(0, 0, 0)
                        add_indent(para, indent_chars=2)
                    else:
                        recursive_parse(child, paragraph)

            recursive_parse(soup, paragraph)

    doc.save(output_path)

# 根据 html 生成 docx
async def gen_doc_without_template(html: str, output_path: str):
    soup = BeautifulSoup(html, 'html.parser')
    doc = Document()
    available_styles = [s.name for s in doc.styles]

    def recursive_parse(element, doc):
        for child in element.children:
            if child.name:
                if child.name.startswith('h') and child.name[1:].isdigit():
                    heading = doc.add_paragraph(child.get_text())
                    style = "Heading %s" % child.name[1:]
                    if style in available_styles:
                        heading.style = style
                    else:
                        heading.style = doc.styles.add_style(style, 1)
                    for run in heading.runs:
                        run.font.size = FONT_SIZE
                        run.font.name = FONT_NAME[child.name]
                        run._element.rPr.rFonts.set(qn("w:eastAsia"), FONT_NAME[child.name])
                        run.font.color.rgb = RGBColor(0, 0, 0)
                        run.font.italic = False
                elif child.name == 'p':
                    para = doc.add_paragraph(child.get_text())
                    for run in para.runs:
                        run.font.size = FONT_SIZE
                        run.font.name = FONT_NAME[child.name]
                        run._element.rPr.rFonts.set(qn("w:eastAsia"), FONT_NAME[child.name])
                        run.font.color.rgb = RGBColor(0, 0, 0)
                    add_indent(para, indent_chars=2)
                else:
                    recursive_parse(child, doc)

    recursive_parse(soup, doc)
    doc.save(output_path)


# 定义清理文件的函数
def cleanup_file(filepath: str):
    try:
        os.remove(filepath)
        log.info(f"已成功删除文件: {filepath}")
    except OSError as e:
        log.error(f"删除文件失败 {filepath}: {e}")

# docx 转 pdf
def convert_docx_to_pdf(input_path) -> str:
    output_path = input_path.replace(".docx", ".pdf")
    try:
        subprocess.run(["libreoffice", "--headless", "--convert-to", "pdf", input_path, "--outdir", STATIC_DIR], check=True)
        print(f"转换成功: {output_path}")
        return output_path
    except subprocess.CalledProcessError as e:
        print(f"转换失败: {e}")
        return ""

# docx 转 wps
def convert_docx_to_wps(input_path) -> str:
    output_path = input_path.replace(".docx", ".wps")
    try:
        subprocess.run(["libreoffice", "--headless", "--convert-to", "wps", input_path, "--outdir", STATIC_DIR], check=True)
        print(f"转换成功: {output_path}")
        return output_path
    except subprocess.CalledProcessError as e:
        print(f"转换失败: {e}")
        return ""

```

docx 生成

doc 需要特殊处理~



常用的文档处理工具如下
```python
from langchain_community.document_loaders import (
    BSHTMLLoader,
    CSVLoader,
    Docx2txtLoader,
    OutlookMessageLoader,
    PyPDFLoader,
    TextLoader,
    UnstructuredEPubLoader,
    UnstructuredExcelLoader,
    UnstructuredMarkdownLoader,
    UnstructuredPowerPointLoader,
    UnstructuredRSTLoader,
    UnstructuredXMLLoader,
    YoutubeLoader,
)
```

问题：docx 可以用 Docx2txtLoader 处理，但是 doc 不行，估计是 doc 格式太老了，不想适配了。

尝试过的无效方案：
- 使用 `from langchain_community.document_loaders import UnstructuredWordDocumentLoader`
- 使用 `pandoc`（不支持 doc 的处理）


可行的解决方案：使用 `LibreOffice`
```python
subprocess.check_output([SOFFICE_PATH, "--headless", "--convert-to", "docx", file_path, "--outdir", dir])
```

大模型文档处理之 doc

![image.png](/static/img/4db44f81000576557aa84a937db48cba.image.png)



# 使用

以 windows 为例
---
- windows 开启 vpn
- windows 开启路由转发
    - 以管理员身份运行 cmd
    - 执行 `reg add HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters /v IPEnableRouter /D 1 /f`
    - 或者进入注册表，将 `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\IPEnableRoute`设为1
    - 进入服务，将 `Routing and Remote Access` 服务的启动类型更改为自动并启动服务
    - 或者在 cmd 执行 `sc config RemoteAccess start= auto` 和 `sc start RemoteAccess`
- mac 开启路由转发 `sudo route add 172.0.0.0/8 192.168.2.2`

# 参考
- [macOS借助vmware隔离运行aTrust，实现宿主机“干净”连入局域网](https://blog.csdn.net/baofeidyz/article/details/129851257)
- [Windows 10上开启路由转发及添加路由](https://blog.csdn.net/weixin_44647835/article/details/109616688)