向量化模型

curl --request POST \
  --url https://$BASE_URL/v1/embeddings \
  --header 'authorization: Bearer 申请到的key' \
  --header 'content-type: application/json' \
  --data '{
    "model": "模型ID",
    "input": [
        "需要转embedding的内容"
    ]
}'

import openai
 
client = openai.OpenAI(
    api_key="申请到的key",  
    base_url="https://$BASE_URL/v1/"
)
 
response = client.embeddings.create(
    model="模型ID",  # model to send to the proxy
    input= ["需要转embedding的内容"],
)
print(response)

package main
 
import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
)
 
// 定义请求结构体
type EmbeddingRequest struct {
    Model string   `json:"model"`
    Input []string `json:"input"`
}
 
// 定义响应结构体
type EmbeddingResponse struct {
    Data []struct {
        Embedding []float64 `json:"embedding"`
        Index     int       `json:"index"`
    } `json:"data"`
    Model  string `json:"model"`
    Object string `json:"object"`
}
 
func main() {
    // 配置参数（建议从环境变量获取）
    apiKey := "申请到的key"
    modelID := "模型ID"
    texts := []string{"需要转embedding的内容"}
 
    // 1. 创建请求体
    reqBody := EmbeddingRequest{
        Model: modelID,
        Input: texts,
    }
 
    // 2. 序列化JSON
    jsonData, err := json.Marshal(reqBody)
    if err != nil {
        log.Fatalf("JSON序列化失败: %v", err)
    }
 
    // 3. 创建HTTP请求
    req, err := http.NewRequest(
        "POST",
        "https://$BASE_URL/v1/embeddings",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        log.Fatalf("创建请求失败: %v", err)
    }
 
    // 4. 设置请求头
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")
 
    // 5. 配置HTTP客户端
    client := &http.Client{
        Timeout: 30 * time.Second, // 设置超时
    }
 
    // 6. 发送请求
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalf("请求发送失败: %v", err)
    }
    defer resp.Body.Close()
 
    // 7. 处理响应状态
    if resp.StatusCode != http.StatusOK {
        body, _ := io.ReadAll(resp.Body)
        log.Fatalf("请求失败 [%d]: %s", resp.StatusCode, string(body))
    }
 
    // 8. 解析响应数据
    var result EmbeddingResponse
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        log.Fatalf("响应解析失败: %v", err)
    }
 
    // 9. 输出结果
    fmt.Println("Embedding生成成功:")
    for _, item := range result.Data {
        fmt.Printf("文本 %d:\n", item.Index+1)
        fmt.Printf("  向量维度: %d\n", len(item.Embedding))
        fmt.Printf("  前5个值: %.4f, %.4f, %.4f, %.4f, %.4f\n",
            item.Embedding[0],
            item.Embedding[1],
            item.Embedding[2],
            item.Embedding[3],
            item.Embedding[4],
        )
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
 
public class EmbeddingGenerator {
    public static void main(String[] args) {
        try {
            // 1. 创建URL对象
            URL url = new URL("https://$BASE_URL/v1/embeddings");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            
            // 2. 配置请求头
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Authorization", "Bearer 申请到的key");
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setDoOutput(true);
 
            // 3. 构建JSON请求体
            String jsonInputString = "{"
                + "\"model\": \"模型ID\","
                + "\"input\": [\"需要转embedding的内容\"]"
                + "}";
 
            // 4. 发送请求
            try(OutputStream os = connection.getOutputStream()) {
                byte[] input = jsonInputString.getBytes("utf-8");
                os.write(input, 0, input.length);
            }
 
            // 5. 处理响应
            int statusCode = connection.getResponseCode();
            if (statusCode == HttpURLConnection.HTTP_OK) {
                try(BufferedReader br = new BufferedReader(
                    new InputStreamReader(connection.getInputStream(), "utf-8"))) {
                    
                    StringBuilder response = new StringBuilder();
                    String responseLine;
                    while ((responseLine = br.readLine()) != null) {
                        response.append(responseLine.trim());
                    }
                    System.out.println("Embedding结果:\n" + response.toString());
                }
            } else {
                System.out.println("请求失败，状态码: " + statusCode);
            }
 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

const axios = require('axios');
 
async function generateEmbeddings() {
    // 配置参数
    const config = {
        headers: {
            'Authorization': 'Bearer 申请到的key',
            'Content-Type': 'application/json'
        },
        timeout: 15000 // 15秒超时
    };
 
    // 请求数据
    const payload = {
        model: "模型ID",
        input: ["需要转embedding的内容"]
    };
 
    try {
        // 发送请求
        const response = await axios.post(
            'https://$BASE_URL/v1/embeddings',
            payload,
            config
        );
 
        // 处理响应
        console.log('请求成功，状态码:', response.status);
        
        // 解析embedding数据
        const embeddings = response.data.data;
        embeddings.forEach((item, index) => {
            console.log(`第${index + 1}个向量维度: ${item.embedding.length}`);
            console.log(`示例向量值: ${item.embedding.slice(0, 5)}...`); // 显示前5个维度
        });
        
        return embeddings;
 
    } catch (error) {
        // 错误处理
        if (error.response) {
            console.error(`请求失败 [${error.response.status}]:`, error.response.data);
        } else if (error.request) {
            console.error('未收到响应:', error.message);
        } else {
            console.error('请求配置错误:', error.message);
        }
        throw error;
    }
}
 
// 执行生成
generateEmbeddings()
    .then(() => console.log('Embedding生成完成'))
    .catch(() => console.log('流程中断'));