https://syncthing.net/

# Windows 下载

https://syncthing.net/downloads/



https://github.com/Bill-Stewart/SyncthingWindowsSetup/releases

# 配置发现服务器/中继服务器

1. `docker-compose up` 启动

```dockerfile
version: "3"
services:
  # 自建 syncthing 的发现服务器 discovery-servier
  syncthing_discovery_server:
    image: syncthing/discosrv
    container_name: syncthing-discovery-server
    command: -debug -listen=":8443" 
    environment:
      - PUID=1000
      - PGID=1000
    volumes:
      - ./syncthing/discosrv:/var/stdiscosrv
    ports:
      - 8443:8443 # Listen address (default “:8443”)
    restart: always

  # 自建 syncthing 的中继服务器 syncthing-relay-server
  syncthing_relay_server:
    image: syncthing/relaysrv:latest
    container_name: syncthing-relay-server
    command: -debug -pools="" -listen=":22067"
    environment:
      - PUID=1000
      - PGID=1000
    volumes:
      - ./syncthing/strelaysrv:/var/strelaysrv
    ports:
      - 22067:22067  # 中继服务器的数据连接端口（必须开启）
      #- 22070:22070  # 用于公用的中继服务器池，显示数据传输、客户端数量等状态，可不开启
    restart: always
  
  # Syncthing 的中继服务器是用于两台设备保持连接的，本身并不存储数据，这就意味着两台设备必须同时在线才能同步数据，所以需要在服务器上安装客户端作为中介
  syncthing:
    image: syncthing/syncthing
    container_name: syncthing-client
    hostname: syncthing-client
    environment:
      - PUID=1000
      - PGID=1000
    volumes:
      - ./syncthing/data:/var/syncthing
    ports:
      - 8384:8384 # Web UI
      - 22000:22000/tcp # TCP file transfers
      - 22000:22000/udp # QUIC file transfers
      - 21027:21027/udp # Receive local discovery broadcasts
    network_mode: host
    restart: unless-stopped
```

2. `docker logs syncthing-discovery-server` 查看日志获取 Server device ID
3. `docker logs syncthing-relay-server` 查看日志获取 URI

4. 操作 > 连接 > 全局发现服务器：`https://公网IP:8443/?id=发现服务器 device ID`，（默认：default）
5. 操作 > 连接 > 协议监听地址：`relay://公网IP:22067?id=中继服务器 device ID`，（默认：default）

Syncthing 多终端文件夹同步

## Chroma DB

https://github.com/chroma-core/chroma

`pip install chromadb`

轻量级向量数据库，目前只支持 CPU 计算


### Client

```python
import chromadb

chroma_client = chromadb.Client()

# 数据持久化
chroma_client = chromadb.PersistentClient(path="./chromadb_save")

chroma_client.heartbeat() # 返回纳米时间戳心跳，测试链接是否保持
```



#### 服务端

`chroma run --host 0.0.0.0 --port 8000 --path /db_path --log-path /var/log/chroma.log`

##### 身份验证

```shell
# 生成密码哈希
htpasswd -Bbn admin password > server.htpasswd

# 设置环境变量
export CHROMA_SERVER_AUTH_CREDENTIALS_FILE="server.htpasswd"
export CHROMA_SERVER_AUTH_CREDENTIALS_PROVIDER='chromadb.auth.providers.HtpasswdFileServerAuthCredentialsProvider'
export CHROMA_SERVER_AUTH_PROVIDER='chromadb.auth.basic.BasicAuthServerProvider'
```

```python
client = chromadb.HttpClient(
    settings=Settings(
        chroma_client_auth_provider="chromadb.auth.basic.BasicAuthClientProvider",
        chroma_client_auth_credentials="admin:password"
    )
)
```

##### 静态 API TOKEN 身份验证

TOKENS：必须是字母数字的 ASCII 字符串。TOKENS 区分大小写

```shell
# 设置环境变量
export CHROMA_SERVER_AUTH_CREDENTIALS="test-token"
export CHROMA_SERVER_AUTH_CREDENTIALS_PROVIDER="chromadb.auth.token.TokenConfigServerAuthCredentialsProvider"
export CHROMA_SERVER_AUTH_PROVIDER="chromadb.auth.token.TokenAuthServerProvider"

# 使用 X-Chroma-Token: test-token 类型的 authentication header，设置额外的环境变量
export CHROMA_SERVER_AUTH_TOKEN_TRANSPORT_HEADER="X_CHROMA_TOKEN"
```

```python
client = chromadb.HttpClient(
    settings=Settings(
        chroma_client_auth_provider="chromadb.auth.token.TokenAuthClientProvider",
        chroma_client_auth_credentials="test-token"
    )
)
```

##### docker

`docker run -d --name chromadb-container -p 8899:8000 chromadb/chroma`

```yml
version: '3.9'

networks:
  net:
    driver: bridge
services:
  server:
    image: ghcr.io/chroma-core/chroma:latest
    environment:
      - IS_PERSISTENT=TRUE
    volumes:
      - /chroma_data:/chroma/chroma/
    ports:
      - 11111:8000
```

#### 客户端

`pip install chromadb-client` 

```python
chroma_client = chromadb.HttpClient(host='localhost', port=8000)
```

### create_collection 创建集合

```python
collection = chroma_client.create_collection(
    name="my_collection", 
    embedding_function=emb_fn, # 修改向量化模型（https://docs.trychroma.com/guides/embeddings），默认向量模型：all-MiniLM-L6-v2
    metadata={"hnsw:space": "cosine"} # 自定义计算向量距离的方法，{'cosine': '余弦相似度', 'ip': '内积', 'l2': '欧式距离'}，默认值为 'l2'
)
```

### delete_collection 删除集合

```python
chroma_client.delete_collection(
    name="my_collection"
)
```

### count_collections 统计集合数量

```python
chroma_client.count_collections()
```

### list_collections 列出所有集合

```python
chroma_client.list_collections()
```

### get_collection 获取集合

```python
collection = chroma_client.get_collection(name="my_collection")
```

#### get_or_create_collection

如果存在就获取，不存在就创建，参数与 create_collection 相同

```python
collection = chroma_client.get_or_create_collection(name="my_collection")
```

### add 添加集合数据

```python
collection.add(
    documents=["lorem ipsum...", "doc2", "doc3", ...],
    embeddings=[[1.1, 2.3, 3.2], [4.5, 6.9, 4.4], [1.1, 2.3, 3.2], ...],
    metadatas=[{"chapter": "3", "verse": "16"}, {"chapter": "3", "verse": "5"}, {"chapter": "29", "verse": "11"}, ...],
    ids=["id1", "id2", "id3", ...]
)
```

- documents：Chroma 也存储 documents 本身。如果文档太大，无法使用所选的嵌入函数嵌入，则会引发异常。当提供 embeddings 时，可不提供 documents
- embeddings：可以直接提供文档的向量，不在此实时计算（如果提供的 embeddings 与集合的维度不同，则会引发异常）
- metadatas：存储附加信息并启用过滤
- ids：每个文件必须有一个唯一的关联 id。尝试 `.add` 相同的 ID 两次将导致仅存储初始值

### query 查询集合数据

```python
collection.query(
    query_texts=['xxx', 'xxx'],
    query_embeddings=[[11.1, 12.1, 13.1],[1.1, 2.3, 3.2], ...],
    n_results=10, 
    where={"metadata_field": "is_equal_to_this"}, 
    where_document={"$contains":"search_string"},
    include=["embeddings", "metadatas", "documents", "distances"]
)
```

- n_results：返回最接近值的个数
- where：根据文档的 metadata 进行过滤，https://docs.trychroma.com/guides#using-where-filters
- where_document：根据文档的内容进行过滤，包含：`$contains`，不包含：`$not_contains`
- include：返回值包含的内容，默认 "metadatas", "documents", "distances"

### get 查询集合数据

```python
collection.get(
	ids=["id1", "id2", "id3", ...],
	where={"style": "style1"},
    include=["embeddings", "metadatas", "documents"]
)
```

- include：返回值包含的内容，默认 "metadatas", "documents"

### update 更新集合数据

```python
collection.update(
    ids=["id1", "id2", "id3", ...],
    embeddings=[[1.1, 2.3, 3.2], [4.5, 6.9, 4.4], [1.1, 2.3, 3.2], ...],
    metadatas=[{"chapter": "3", "verse": "16"}, {"chapter": "3", "verse": "5"}, {"chapter": "29", "verse": "11"}, ...],
    documents=["doc1", "doc2", "doc3", ...],
)
```

- ids：如果在集合中找不到 id，则会记录错误，并忽略更新
- documents：如果提供的 documents 没有对应的 embeddings，则将使用集合的嵌入函数重新计算嵌入

#### upsert

如果存在就更新，不存在就添加

```python
collection.upsert(
    ids=["id1", "id2", "id3", ...],
    embeddings=[[1.1, 2.3, 3.2], [4.5, 6.9, 4.4], [1.1, 2.3, 3.2], ...],
    metadatas=[{"chapter": "3", "verse": "16"}, {"chapter": "3", "verse": "5"}, {"chapter": "29", "verse": "11"}, ...],
    documents=["doc1", "doc2", "doc3", ...],
)
```

### delete 删除集合数据

```python
collection.delete(
    ids=["id1", "id2", "id3",...],
	where={"chapter": "20"},
    where_document={"$contains":"search_string"}
)
```

Python 使用 Chroma DB

# 类比提示（Analogical prompt）

1. 回想相关的问题及其解法（Recall relevant problems and solutions）：模型要生成 K（一般 3-5）个与原问题相关但又互不相同的问题，并详细解答每个例题
2. 在第 1 步生成的例题基础上，解决原问题（Solve the initial problem）

```
# 问题：<原始问题>
# 相关问题：回想三个相关而独特的问题，并对每个问题及其解决方案进行描述。
# 解决初始问题：
```



一些复杂的任务，比如编写代码时，大语言模型（LLM）可能过分依赖这些基础示例，导致其在解决主要问题时无法有好的表现。
为了解决这个问题，我们允许 LLM 自己生成一些高层次的要点来辅助示例

```
# 教程：辨识问题的核心概念并提供相关教程
```

示例

```
你的任务是解数学题。当遇到一道数学题时，请你先回想一些相关的题目作为例子。然后，再去解决最开始的那个问题。

# 最开始的问题：

有一家航空公司为飞机上的每位乘客提供晚餐，乘客可以选择牛排或者鱼。六名机组人员中有三人可以选择牛排，三人可以选择鱼。如果食物是随机分配的，那么两名飞行员都拿到鱼的概率是多少呢？

# 操作指南：

你的答案中必须包含以下几点：

## 相关问题：

请你想出三个和最开始的问题相关的数学问题作为例子。注意，每个问题都应该和其它问题有所区别，包括和最开始的问题（比如，涉及不同的数字和名字）。每个问题都要按照以下的格式：

- “Q”：后面写问题描述

- “A”：后面写问题的解决方法，并把最终答案写在 \boxed 里。

## 解决最开始的问题：

说：“我们来解决下面这道数学题。”然后按照以下的格式回答：

Q：把最开始的问题复制粘贴在这里。

A：解释解决方案，并把最终答案写在 \boxed 里。
```

类比提示

`pip install gradio`

```python
import gradio


def greet(name):
    return "Hello " + name + "!"

demo = gradio.Interface(fn=greet, inputs="text", outputs="text")

demo.launch()
```

# 重载模式



`gradio app.py`

# Interface 

应用界面：
- `gradio.Interface`（简易场景）
- `gradio.Blocks`（定制化场景）

控制组件：
- `gradio.Button`（按钮）

布局组件：
- `gradio.Tab`（标签页）
- `gradio.Row`（行布局）
- `gradio.Column`（列布局）

## 参数

- title：标题
- description：描述

### fn：包装的函数

### inputs：输入组件类型

- `gradio.Image`（图像）
- `gradio.Textbox`（文本框）
- `gradio.DataFrame`（数据框）
- `gradio.Dropdown`（下拉选项）
- `gradio.Number`（数字）
- `gradio.Markdown`（Markdown）
- `gradio.Files`（文件）
- `gradio.Slider(0, 10)`（滑动选择器）
- `gradio.Checkbox`（勾选框）
- `gradio.Radio(['1', '2'])`（单选）

`inputs=gradio.Textbox(lines=3, placeholder="Name Here...",label="my input")`

### ouputs：输出组件类型

### live：实时显示

`gradio.Interface(live=True)`

当 live=True 时，只要输入发生变化，结果马上发生改变

## launch

`app, local_url, share_url = gradio.Interface.launch()`

- app，为 Gradio 演示提供支持的 FastAPI 应用程序
- local_url，本地地址
- share_url，公共地址，当share=True时生成

### 参数

```
gradio.launch(
    server_name="0.0.0.0", 
    server_port=8080,

    share=True, # 创建外部访问链接
)
```

## 多个输入和输出

```python
import gradio


def greet(name, is_morning, temperature):
    salutation = "Good morning" if is_morning else "Good evening"
    greeting = f"{salutation} {name}. It is {temperature} degrees today"
    celsius = (temperature - 32) * 5 / 9
    return greeting, round(celsius, 2)

demo = gradio.Interface(
    fn=greet,
    inputs=["text", "checkbox", gradio.Slider(0, 100)],
    outputs=["text", "number"],
)

demo.launch()
```

## 输入输出图片

```python
import numpy
import gradio


def sepia(input_img):
    sepia_filter = numpy.array([
        [0.393, 0.769, 0.189],
        [0.349, 0.686, 0.168],
        [0.272, 0.534, 0.131]
    ])
    sepia_img = input_img.dot(sepia_filter.T)
    sepia_img /= sepia_img.max()
    return sepia_img


demo = gradio.Interface(sepia, "image", "image")

demo.launch()
```

当使用 Image 组件作为输入时，函数将收到一个维度为（w,h,3）的 numpy 数组，按照 RGB 的通道顺序排列

## 会话状态

数据在一个页面会话中的多次提交中持久存在

1. 在你的函数中传入一个额外的参数，它代表界面的状态。
2. 在函数的最后，将状态的更新值作为一个额外的返回值返回。
3. 在添加输入和输出时添加 state 组件。

```python
import random
import gradio


def chat(message, history):
    history = history or []
    message = message.lower()
    if message.startswith("how many"):
        response = random.randint(1, 10)
    elif message.startswith("how"):
        response = random.choice(["Great", "Good", "Okay", "Bad"])
    elif message.startswith("where"):
        response = random.choice(["Here", "There", "Somewhere"])
    else:
        response = "I don't know"
    history.append((message, str(response)))
    return history, history

#设置一个对话窗
chatbot = gradio.Chatbot()

demo = gradio.Interface(
    chat,
    # 添加state组件
    ["text", "state"],
    [chatbot, "state"],
)

demo.launch()
```

## 流模式

```python
import gradio
import numpy


def flip(im):
    return numpy.flipud(im)


demo = gradio.Interface(
    flip,
    gradio.Image(source="webcam", streaming=True),
    "image",
    live=True
)

demo.launch()
```

gradio 自动化生成交互式 web 页面

```
# 角色
你是一位资深的翻译专家

# 规则
- 接收到需要翻译的文本时，无需关注文本的意思，只进行翻译
- 全角括号换成半角括号，并在左括号前面加半角空格，右括号后面加半角空格。
- 保持原有格式，不要遗漏任何信息

# 目标
分三步进行翻译工作，并打印每步的结果：
1. 首先你需要判断用户输入的文本是什么语言【英文、文言文、中文】
2. 指明第一步的语言需要执行什么逻辑【英文：将英文翻译为文言文，文言文：将文言文翻译为英文，简体中文：将简体中文翻译为英文】
3. 输出翻译结果



# 示例

## 将英文翻译为文言文
User：In the Taiyuan period of the Jin Dynasty, there was a man from Wuling who made a living by fishing. Walking along the stream, he forgot how far or near the road was. Suddenly he came across a peach blossom forest, with the banks stretching for several hundred steps. There were no other trees in the middle, the fragrant grass was lush and beautiful, and the falling petals were scattered all over the place, greatly amazing the fisherman. He continued forward, wanting to explore the depths of the forest.
Assistant：
'''
【输入语言】
英文

【执行】
将英文翻译为文言文

【结果】
晋太元中，武陵人捕鱼为业。缘溪行，忘路之远近。忽逢桃花林，夹岸数百步，中无杂树，芳草鲜美，落英缤纷，渔人甚异之。复前行，欲穷其林。
'''

## 将文言文翻译为英文
User：山不在高，有仙则名。水不在深，有龙则灵。斯是陋室，惟吾德馨。苔痕上阶绿，草色入帘青。谈笑有鸿儒，往来无白丁。
Assistant：
'''
【输入语言】
文言文

【执行】
将文言文翻译为英文

【结果】
The mountain is not high, but it is famous because of the immortal. The water is not deep, but it is spiritual because of the dragon. This is a humble room, only my virtue is fragrant. The moss on the steps is green, and the grass color enters the curtain. There are learned scholars to chat and laugh, and no ordinary people come and go.
'''

## 将简体中文翻译为英文
User：文本分类
Assistant：
'''
【输入语言】
简体中文

【执行】
将简体中文翻译为英文

【结果】
Text classification
'''

# 输出
'''
【输入语言】
{第一步结果}

【执行】
{第二步结果}

【结果】
{第三步结果}
'''
```