知识库API指南

export ALIBABA_CLOUD_ACCESS_KEY_ID='您的阿里云访问密钥ID'
export ALIBABA_CLOUD_ACCESS_KEY_SECRET='您的阿里云访问密钥密码'
export WORKSPACE_ID='您的阿里云百炼业务空间ID'

# 示例代码仅供参考，请勿在生产环境中直接使用
import hashlib
import os
import time

import requests
from alibabacloud_bailian20231229 import models as bailian_20231229_models
from alibabacloud_bailian20231229.client import Client as bailian20231229Client
from alibabacloud_tea_openapi import models as open_api_models
from alibabacloud_tea_util import models as util_models

def check_environment_variables():
"""检查并提示设置必要的环境变量"""
required_vars = {
'ALIBABA_CLOUD_ACCESS_KEY_ID': '阿里云访问密钥ID',
'ALIBABA_CLOUD_ACCESS_KEY_SECRET': '阿里云访问密钥密码',
'WORKSPACE_ID': '阿里云百炼业务空间ID'
}
missing_vars = []
for var, description in required_vars.items():
if not os.environ.get(var):
missing_vars.append(var)
print(f"错误：请设置 {var} 环境变量 ({description})")

return len(missing_vars) == 0

def calculate_md5(file_path: str) -> str:
"""
计算文件的MD5值。

参数:
file_path (str): 文件本地路径。

返回:
str: 文件的MD5值。
"""
md5_hash = hashlib.md5()

# 以二进制形式读取文件
with open(file_path, "rb") as f:
# 按块读取文件，避免大文件占用过多内存
for chunk in iter(lambda: f.read(4096), b""):
md5_hash.update(chunk)

return md5_hash.hexdigest()

def get_file_size(file_path: str) -> int:
"""
获取文件大小（以字节为单位）。
参数:
file_path (str): 文件本地路径。
返回:
int: 文件大小（以字节为单位）。
"""
return os.path.getsize(file_path)

# 初始化客户端（Client）
def create_client() -> bailian20231229Client:
"""
创建并配置客户端（Client）。

返回:
bailian20231229Client: 配置好的客户端（Client）。
"""
config = open_api_models.Config(
access_key_id=os.environ.get('ALIBABA_CLOUD_ACCESS_KEY_ID'),
access_key_secret=os.environ.get('ALIBABA_CLOUD_ACCESS_KEY_SECRET')
)
# 下方接入地址以公有云的公网接入地址为例，可按需更换接入地址。
config.endpoint = 'bailian.cn-beijing.aliyuncs.com'
return bailian20231229Client(config)

# 申请文件上传租约
def apply_lease(client, category_id, file_name, file_md5, file_size, workspace_id):
"""
从阿里云百炼服务申请文件上传租约。

参数:
client (bailian20231229Client): 客户端（Client）。
category_id (str): 类目ID。
file_name (str): 文件名称。
file_md5 (str): 文件的MD5值。
file_size (int): 文件大小（以字节为单位）。
workspace_id (str): 业务空间ID。

返回:
阿里云百炼服务的响应。
"""
headers = {}
request = bailian_20231229_models.ApplyFileUploadLeaseRequest(
file_name=file_name,
md_5=file_md5,
size_in_bytes=file_size,
)
runtime = util_models.RuntimeOptions()
return client.apply_file_upload_lease_with_options(category_id, workspace_id, request, headers, runtime)

# 上传文件到临时存储
def upload_file(pre_signed_url, headers, file_path):
"""
将文件上传到阿里云百炼服务。
参数:
pre_signed_url (str): 上传租约中的 URL。
headers (dict): 上传请求的头部。
file_path (str): 文件本地路径。
"""
with open(file_path, 'rb') as f:
file_content = f.read()
upload_headers = {
"X-bailian-extra": headers["X-bailian-extra"],
"Content-Type": headers["Content-Type"]
}
response = requests.put(pre_signed_url, data=file_content, headers=upload_headers)
response.raise_for_status()

# 添加文件到类目中
def add_file(client: bailian20231229Client, lease_id: str, parser: str, category_id: str, workspace_id: str):
"""
将文件添加到阿里云百炼服务的指定类目中。

参数:
client (bailian20231229Client): 客户端（Client）。
lease_id (str): 租约ID。
parser (str): 用于文件的解析器。
category_id (str): 类目ID。
workspace_id (str): 业务空间ID。

返回:
阿里云百炼服务的响应。
"""
headers = {}
request = bailian_20231229_models.AddFileRequest(
lease_id=lease_id,
parser=parser,
category_id=category_id,
)
runtime = util_models.RuntimeOptions()
return client.add_file_with_options(workspace_id, request, headers, runtime)

# 查询文件的解析状态
def describe_file(client, workspace_id, file_id):
"""
获取文件的基本信息。

参数:
client (bailian20231229Client): 客户端（Client）。
workspace_id (str): 业务空间ID。
file_id (str): 文件ID。

返回:
阿里云百炼服务的响应。
"""
headers = {}
runtime = util_models.RuntimeOptions()
return client.describe_file_with_options(workspace_id, file_id, headers, runtime)

# 初始化知识库（索引）
def create_index(client, workspace_id, file_id, name, structure_type, source_type, sink_type):
"""
在阿里云百炼服务中创建知识库（初始化）。

参数:
client (bailian20231229Client): 客户端（Client）。
workspace_id (str): 业务空间ID。
file_id (str): 文件ID。
name (str): 知识库名称。
structure_type (str): 知识库的数据类型。
source_type (str): 应用数据的数据类型，支持类目类型和文件类型。
sink_type (str): 知识库的向量存储类型。

返回:
阿里云百炼服务的响应。
"""
headers = {}
request = bailian_20231229_models.CreateIndexRequest(
structure_type=structure_type,
name=name,
source_type=source_type,
sink_type=sink_type,
document_ids=[file_id]
)
runtime = util_models.RuntimeOptions()
return client.create_index_with_options(workspace_id, request, headers, runtime)

# 提交索引任务
def submit_index(client, workspace_id, index_id):
"""
向阿里云百炼服务提交索引任务。

参数:
client (bailian20231229Client): 客户端（Client）。
workspace_id (str): 业务空间ID。
index_id (str): 知识库ID。

返回:
阿里云百炼服务的响应。
"""
headers = {}
submit_index_job_request = bailian_20231229_models.SubmitIndexJobRequest(
index_id=index_id
)
runtime = util_models.RuntimeOptions()
return client.submit_index_job_with_options(workspace_id, submit_index_job_request, headers, runtime)

# 等待索引任务完成
def get_index_job_status(client, workspace_id, job_id, index_id):
"""
查询索引任务状态。

参数:
client (bailian20231229Client): 客户端（Client）。
workspace_id (str): 业务空间ID。
index_id (str): 知识库ID。
job_id (str): 任务ID。

返回:
阿里云百炼服务的响应。
"""
headers = {}
get_index_job_status_request = bailian_20231229_models.GetIndexJobStatusRequest(
index_id=index_id,
job_id=job_id
)
runtime = util_models.RuntimeOptions()
return client.get_index_job_status_with_options(workspace_id, get_index_job_status_request, headers, runtime)

def create_knowledge_base(
file_path: str,
workspace_id: str,
name: str
):
"""
使用阿里云百炼服务创建知识库。
参数:
file_path (str): 文件本地路径。
workspace_id (str): 业务空间ID。
name (str): 知识库名称。
返回:
str or None: 如果成功，返回知识库ID；否则返回None。
"""
# 设置默认值
category_id = 'default'
parser = 'DASHSCOPE_DOCMIND'
source_type = 'DATA_CENTER_FILE'
structure_type = 'unstructured'
sink_type = 'DEFAULT'
try:
# 步骤1：初始化客户端（Client）
print("步骤1：初始化Client")
client = create_client()
# 步骤2：准备文件信息
print("步骤2：准备文件信息")
file_name = os.path.basename(file_path)
file_md5 = calculate_md5(file_path)
file_size = get_file_size(file_path)
# 步骤3：申请上传租约
print("步骤3：向阿里云百炼申请上传租约")
lease_response = apply_lease(client, category_id, file_name, file_md5, file_size, workspace_id)
lease_id = lease_response.body.data.file_upload_lease_id
upload_url = lease_response.body.data.param.url
upload_headers = lease_response.body.data.param.headers
# 步骤4：上传文件
print("步骤4：上传文件到阿里云百炼")
upload_file(upload_url, upload_headers, file_path)
# 步骤5：将文件添加到服务器
print("步骤5：将文件添加到阿里云百炼服务器")
add_response = add_file(client, lease_id, parser, category_id, workspace_id)
file_id = add_response.body.data.file_id
# 步骤6：检查文件状态
print("步骤6：检查阿里云百炼中的文件状态")
while True:
describe_response = describe_file(client, workspace_id, file_id)
status = describe_response.body.data.status
print(f"当前文件状态：{status}")
if status == 'INIT':
print("文件待解析，请稍候...")
elif status == 'PARSING':
print("文件解析中，请稍候...")
elif status == 'PARSE_SUCCESS':
print("文件解析完成！")
break
else:
print(f"未知的文件状态：{status}，请联系技术支持。")
return None
time.sleep(5)
# 步骤7：初始化知识库
print("步骤7：在阿里云百炼中初始化知识库")
index_response = create_index(client, workspace_id, file_id, name, structure_type, source_type, sink_type)
index_id = index_response.body.data.id
# 步骤8：提交索引任务
print("步骤8：向阿里云百炼提交索引任务")
submit_response = submit_index(client, workspace_id, index_id)
job_id = submit_response.body.data.id
# 步骤9：获取索引任务状态
print("步骤9：获取阿里云百炼索引任务状态")
while True:
get_index_job_status_response = get_index_job_status(client, workspace_id, job_id, index_id)
status = get_index_job_status_response.body.data.status
print(f"当前索引任务状态：{status}")
if status == 'COMPLETED':
break
time.sleep(5)
print("阿里云百炼知识库创建成功！")
return index_id
except Exception as e:
print(f"发生错误：{e}")
return None

def main():
if not check_environment_variables():
print("环境变量校验未通过。")
return
file_path = input("请输入您需要上传文件的实际本地路径（以Linux为例：/xxx/xxx/阿里云百炼系列手机产品介绍.docx）：")
kb_name = input("请为您的知识库输入一个名称：")
workspace_id = os.environ.get('WORKSPACE_ID')
create_knowledge_base(file_path, workspace_id, kb_name)

if __name__ == '__main__':
main()

// 示例代码仅供参考，请勿在生产环境中直接使用
import com.aliyun.bailian20231229.models.*;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.File;
import java.io.FileInputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.MessageDigest;
import java.util.*;
import java.util.concurrent.TimeUnit;

public class KnowledgeBaseCreate {

/**
* 检查并提示设置必要的环境变量。
*
* @return true 如果所有必需的环境变量都已设置，否则 false
*/
public static boolean checkEnvironmentVariables() {
Map<String, String> requiredVars = new HashMap<>();
requiredVars.put("ALIBABA_CLOUD_ACCESS_KEY_ID", "阿里云访问密钥ID");
requiredVars.put("ALIBABA_CLOUD_ACCESS_KEY_SECRET", "阿里云访问密钥密码");
requiredVars.put("WORKSPACE_ID", "阿里云百炼业务空间ID");

List<String> missingVars = new ArrayList<>();
for (Map.Entry<String, String> entry : requiredVars.entrySet()) {
String value = System.getenv(entry.getKey());
if (value == null || value.isEmpty()) {
missingVars.add(entry.getKey());
System.out.println("错误：请设置 " + entry.getKey() + " 环境变量 (" + entry.getValue() + ")");
}
}

return missingVars.isEmpty();
}

/**
* 计算文件的MD5值。
*
* @param filePath 文件本地路径
* @return 文件的MD5值
* @throws Exception 如果计算过程中发生错误
*/
public static String calculateMD5(String filePath) throws Exception {
MessageDigest md = MessageDigest.getInstance("MD5");
try (FileInputStream fis = new FileInputStream(filePath)) {
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
md.update(buffer, 0, bytesRead);
}
}
StringBuilder sb = new StringBuilder();
for (byte b : md.digest()) {
sb.append(String.format("%02x", b & 0xff));
}
return sb.toString();
}

/**
* 获取文件大小（以字节为单位）。
*
* @param filePath 文件本地路径
* @return 文件大小（以字节为单位）
*/
public static String getFileSize(String filePath) {
File file = new File(filePath);
long fileSize = file.length();
return String.valueOf(fileSize);
}

/**
* 初始化客户端（Client）。
*
* @return 配置好的客户端对象
*/
public static com.aliyun.bailian20231229.Client createClient() throws Exception {
com.aliyun.teaopenapi.models.Config config = new com.aliyun.teaopenapi.models.Config()
.setAccessKeyId(System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"))
.setAccessKeySecret(System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET"));
// 下方接入地址以公有云的公网接入地址为例，可按需更换接入地址。
config.endpoint = "bailian.cn-beijing.aliyuncs.com";
return new com.aliyun.bailian20231229.Client(config);
}

/**
* 申请文件上传租约。
*
* @param client      客户端对象
* @param categoryId  类目ID
* @param fileName    文件名称
* @param fileMd5     文件的MD5值
* @param fileSize    文件大小（以字节为单位）
* @param workspaceId 业务空间ID
* @return 阿里云百炼服务的响应对象
*/
public static ApplyFileUploadLeaseResponse applyLease(com.aliyun.bailian20231229.Client client, String categoryId, String fileName, String fileMd5, String fileSize, String workspaceId) throws Exception {
Map<String, String> headers = new HashMap<>();
com.aliyun.bailian20231229.models.ApplyFileUploadLeaseRequest applyFileUploadLeaseRequest = new com.aliyun.bailian20231229.models.ApplyFileUploadLeaseRequest();
applyFileUploadLeaseRequest.setFileName(fileName);
applyFileUploadLeaseRequest.setMd5(fileMd5);
applyFileUploadLeaseRequest.setSizeInBytes(fileSize);
com.aliyun.teautil.models.RuntimeOptions runtime = new com.aliyun.teautil.models.RuntimeOptions();
ApplyFileUploadLeaseResponse applyFileUploadLeaseResponse = null;
applyFileUploadLeaseResponse = client.applyFileUploadLeaseWithOptions(categoryId, workspaceId, applyFileUploadLeaseRequest, headers, runtime);
return applyFileUploadLeaseResponse;
}

/**
* 上传文件到临时存储。
*
* @param preSignedUrl 上传租约中的 URL
* @param headers      上传请求的头部
* @param filePath     文件本地路径
* @throws Exception 如果上传过程中发生错误
*/
public static void uploadFile(String preSignedUrl, Map<String, String> headers, String filePath) throws Exception {
File file = new File(filePath);
if (!file.exists() || !file.isFile()) {
throw new IllegalArgumentException("文件不存在或不是普通文件: " + filePath);
}

try (FileInputStream fis = new FileInputStream(file)) {
URL url = new URL(preSignedUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("PUT");
conn.setDoOutput(true);

// 设置上传请求头
conn.setRequestProperty("X-bailian-extra", headers.get("X-bailian-extra"));
conn.setRequestProperty("Content-Type", headers.get("Content-Type"));

// 分块读取并上传文件
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
conn.getOutputStream().write(buffer, 0, bytesRead);
}

int responseCode = conn.getResponseCode();
if (responseCode != 200) {
throw new RuntimeException("上传失败: " + responseCode);
}
}
}

/**
* 将文件添加到类目中。
*
* @param client      客户端对象
* @param leaseId     租约ID
* @param parser      用于文件的解析器
* @param categoryId  类目ID
* @param workspaceId 业务空间ID
* @return 阿里云百炼服务的响应对象
*/
public static AddFileResponse addFile(com.aliyun.bailian20231229.Client client, String leaseId, String parser, String categoryId, String workspaceId) throws Exception {
Map<String, String> headers = new HashMap<>();
com.aliyun.bailian20231229.models.AddFileRequest addFileRequest = new com.aliyun.bailian20231229.models.AddFileRequest();
addFileRequest.setLeaseId(leaseId);
addFileRequest.setParser(parser);
addFileRequest.setCategoryId(categoryId);
com.aliyun.teautil.models.RuntimeOptions runtime = new com.aliyun.teautil.models.RuntimeOptions();
return client.addFileWithOptions(workspaceId, addFileRequest, headers, runtime);
}

/**
* 查询文件的基本信息。
*
* @param client      客户端对象
* @param workspaceId 业务空间ID
* @param fileId      文件ID
* @return 阿里云百炼服务的响应对象
*/
public static DescribeFileResponse describeFile(com.aliyun.bailian20231229.Client client, String workspaceId, String fileId) throws Exception {
Map<String, String> headers = new HashMap<>();
com.aliyun.teautil.models.RuntimeOptions runtime = new com.aliyun.teautil.models.RuntimeOptions();
return client.describeFileWithOptions(workspaceId, fileId, headers, runtime);
}

/**
* 在阿里云百炼服务中创建知识库（初始化）。
*
* @param client        客户端对象
* @param workspaceId   业务空间ID
* @param fileId        文件ID
* @param name          知识库名称
* @param structureType 知识库的数据类型
* @param sourceType    应用数据的数据类型，支持类目类型和文件类型
* @param sinkType      知识库的向量存储类型
* @return 阿里云百炼服务的响应对象
*/
public static CreateIndexResponse createIndex(com.aliyun.bailian20231229.Client client, String workspaceId, String fileId, String name, String structureType, String sourceType, String sinkType) throws Exception {
Map<String, String> headers = new HashMap<>();
com.aliyun.bailian20231229.models.CreateIndexRequest createIndexRequest = new com.aliyun.bailian20231229.models.CreateIndexRequest();
createIndexRequest.setStructureType(structureType);
createIndexRequest.setName(name);
createIndexRequest.setSourceType(sourceType);
createIndexRequest.setSinkType(sinkType);
createIndexRequest.setDocumentIds(Collections.singletonList(fileId));
com.aliyun.teautil.models.RuntimeOptions runtime = new com.aliyun.teautil.models.RuntimeOptions();
return client.createIndexWithOptions(workspaceId, createIndexRequest, headers, runtime);
}

/**
* 向阿里云百炼服务提交索引任务。
*
* @param client      客户端对象
* @param workspaceId 业务空间ID
* @param indexId     知识库ID
* @return 阿里云百炼服务的响应对象
*/
public static SubmitIndexJobResponse submitIndex(com.aliyun.bailian20231229.Client client, String workspaceId, String indexId) throws Exception {
Map<String, String> headers = new HashMap<>();
com.aliyun.bailian20231229.models.SubmitIndexJobRequest submitIndexJobRequest = new com.aliyun.bailian20231229.models.SubmitIndexJobRequest();
submitIndexJobRequest.setIndexId(indexId);
com.aliyun.teautil.models.RuntimeOptions runtime = new com.aliyun.teautil.models.RuntimeOptions();
return client.submitIndexJobWithOptions(workspaceId, submitIndexJobRequest, headers, runtime);
}

/**
* 查询索引任务状态。
*
* @param client      客户端对象
* @param workspaceId 业务空间ID
* @param jobId       任务ID
* @param indexId     知识库ID
* @return 阿里云百炼服务的响应对象
*/
public static GetIndexJobStatusResponse getIndexJobStatus(com.aliyun.bailian20231229.Client client, String workspaceId, String jobId, String indexId) throws Exception {
Map<String, String> headers = new HashMap<>();
com.aliyun.bailian20231229.models.GetIndexJobStatusRequest getIndexJobStatusRequest = new com.aliyun.bailian20231229.models.GetIndexJobStatusRequest();
getIndexJobStatusRequest.setIndexId(indexId);
getIndexJobStatusRequest.setJobId(jobId);
com.aliyun.teautil.models.RuntimeOptions runtime = new com.aliyun.teautil.models.RuntimeOptions();
GetIndexJobStatusResponse getIndexJobStatusResponse = null;
getIndexJobStatusResponse = client.getIndexJobStatusWithOptions(workspaceId, getIndexJobStatusRequest, headers, runtime);
return getIndexJobStatusResponse;
}

/**
* 使用阿里云百炼服务创建知识库。
*
* @param filePath    文件本地路径
* @param workspaceId 业务空间ID
* @param name        知识库名称
* @return 如果成功，返回知识库ID；否则返回 null
*/
public static String createKnowledgeBase(String filePath, String workspaceId, String name) {
// 设置默认值
String categoryId = "default";
String parser = "DASHSCOPE_DOCMIND";
String sourceType = "DATA_CENTER_FILE";
String structureType = "unstructured";
String sinkType = "DEFAULT";
try {
// 步骤1：初始化客户端（Client）
System.out.println("步骤1：初始化Client");
com.aliyun.bailian20231229.Client client = createClient();

// 步骤2：准备文件信息
System.out.println("步骤2：准备文件信息");
String fileName = new File(filePath).getName();
String fileMd5 = calculateMD5(filePath);
String fileSize = getFileSize(filePath);

// 步骤3：申请上传租约
System.out.println("步骤3：向阿里云百炼申请上传租约");
ApplyFileUploadLeaseResponse leaseResponse = applyLease(client, categoryId, fileName, fileMd5, fileSize, workspaceId);
String leaseId = leaseResponse.getBody().getData().getFileUploadLeaseId();
String uploadUrl = leaseResponse.getBody().getData().getParam().getUrl();
Object uploadHeaders = leaseResponse.getBody().getData().getParam().getHeaders();

// 步骤4：上传文件
System.out.println("步骤4：上传文件到阿里云百炼");
// 请自行安装jackson-databind
// 将上一步的uploadHeaders转换为Map(Key-Value形式)
ObjectMapper mapper = new ObjectMapper();
Map<String, String> uploadHeadersMap = (Map<String, String>) mapper.readValue(mapper.writeValueAsString(uploadHeaders), Map.class);
uploadFile(uploadUrl, uploadHeadersMap, filePath);

// 步骤5：将文件添加到服务器
System.out.println("步骤5：将文件添加到阿里云百炼服务器");
AddFileResponse addResponse = addFile(client, leaseId, parser, categoryId, workspaceId);
String fileId = addResponse.getBody().getData().getFileId();

// 步骤6：检查文件状态
System.out.println("步骤6：检查阿里云百炼中的文件状态");
while (true) {
DescribeFileResponse describeResponse = describeFile(client, workspaceId, fileId);
String status = describeResponse.getBody().getData().getStatus();
System.out.println("当前文件状态：" + status);

if (status.equals("INIT")) {
System.out.println("文件待解析，请稍候...");
} else if (status.equals("PARSING")) {
System.out.println("文件解析中，请稍候...");
} else if (status.equals("PARSE_SUCCESS")) {
System.out.println("文件解析完成！");
break;
} else {
System.out.println("未知的文件状态：" + status + "，请联系技术支持。");
return null;
}
TimeUnit.SECONDS.sleep(5);
}

// 步骤7：初始化知识库
System.out.println("步骤7：在阿里云百炼中创建知识库");
CreateIndexResponse indexResponse = createIndex(client, workspaceId, fileId, name, structureType, sourceType, sinkType);
String indexId = indexResponse.getBody().getData().getId();

// 步骤8：提交索引任务
System.out.println("步骤8：向阿里云百炼提交索引任务");
SubmitIndexJobResponse submitResponse = submitIndex(client, workspaceId, indexId);
String jobId = submitResponse.getBody().getData().getId();

// 步骤9：获取索引任务状态
System.out.println("步骤9：获取阿里云百炼索引任务状态");
while (true) {
GetIndexJobStatusResponse getStatusResponse = getIndexJobStatus(client, workspaceId, jobId, indexId);
String status = getStatusResponse.getBody().getData().getStatus();
System.out.println("当前索引任务状态：" + status);

if (status.equals("COMPLETED")) {
break;
}
TimeUnit.SECONDS.sleep(5);
}

System.out.println("阿里云百炼知识库创建成功！");
return indexId;

} catch (Exception e) {
System.out.println("发生错误：" + e.getMessage());
e.printStackTrace();
return null;
}
}

/**
* 主函数。
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
if (!checkEnvironmentVariables()) {
return;
}

System.out.print("请输入您需要上传文件的实际本地路径（以Linux为例：/xxx/xxx/阿里云百炼系列手机产品介绍.docx）：");
String filePath = scanner.nextLine();

System.out.print("请为您的知识库输入一个名称：");
String kbName = scanner.nextLine();

String workspaceId = System.getenv("WORKSPACE_ID");
String result = createKnowledgeBase(filePath, workspaceId, kbName);
if (result != null) {
System.out.println("知识库ID: " + result);
}
}
}

<?php
// 示例代码仅供参考，请勿在生产环境中直接使用
namespace AlibabaCloud\SDK\Sample;

use AlibabaCloud\Dara\Models\RuntimeOptions;
use AlibabaCloud\SDK\Bailian\V20231229\Bailian;
use AlibabaCloud\SDK\Bailian\V20231229\Models\AddFileRequest;
use \Exception;

use Darabonba\OpenApi\Models\Config;
use AlibabaCloud\SDK\Bailian\V20231229\Models\ApplyFileUploadLeaseRequest;
use AlibabaCloud\SDK\Bailian\V20231229\Models\CreateIndexRequest;
use AlibabaCloud\SDK\Bailian\V20231229\Models\SubmitIndexJobRequest;
use AlibabaCloud\SDK\Bailian\V20231229\Models\GetIndexJobStatusRequest;

class KnowledgeBaseCreate {

/**
* 检查并提示设置必要的环境变量。
*
* @return bool 返回 true 如果所有必需的环境变量都已设置，否则 false。
*/
public static function checkEnvironmentVariables() {
$requiredVars = [
'ALIBABA_CLOUD_ACCESS_KEY_ID' => '阿里云访问密钥ID',
'ALIBABA_CLOUD_ACCESS_KEY_SECRET' => '阿里云访问密钥密码',
'WORKSPACE_ID' => '阿里云百炼业务空间ID'
];
$missingVars = [];
foreach ($requiredVars as $var => $description) {
if (!getenv($var)) {
$missingVars[] = $var;
echo "错误：请设置 $var 环境变量 ($description)\n";
}
}
return count($missingVars) === 0;
}

/**
* 计算文件的MD5值。
*
* @param string $filePath 文件本地路径。
* @return string 文件的MD5值。
*/
public static function calculateMd5($filePath) {
$md5Hash = hash_init("md5");
$handle = fopen($filePath, "rb");
while (!feof($handle)) {
$chunk = fread($handle, 4096);
hash_update($md5Hash, $chunk);
}
fclose($handle);
return hash_final($md5Hash);
}

/**
* 获取文件大小（以字节为单位）。
*
* @param string $filePath 文件本地路径。
* @return int 文件大小（以字节为单位）。
*/
public static function getFileSize($filePath) {
return (string)filesize($filePath);
}

/**
* 初始化客户端（Client）。
*
* @return Bailian 配置好的客户端对象（Client）。
*/
public static function createClient(){
$config = new Config([
"accessKeyId" => getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"),
"accessKeySecret" => getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")
]);
// 下方接入地址以公有云的公网接入地址为例，可按需更换接入地址。
$config->endpoint = 'bailian.cn-beijing.aliyuncs.com';
return new Bailian($config);
}

/**
* 申请文件上传租约。
*
* @param Bailian $client 客户端（Client）。
* @param string $categoryId 类目ID。
* @param string $fileName 文件名称。
* @param string $fileMd5 文件的MD5值。
* @param int $fileSize 文件大小（以字节为单位）。
* @param string $workspaceId 业务空间ID。
* @return ApplyFileUploadLeaseResponse 阿里云百炼服务的响应。
*/
public static function applyLease($client, $categoryId, $fileName, $fileMd5, $fileSize, $workspaceId) {
$headers = [];
$applyFileUploadLeaseRequest = new ApplyFileUploadLeaseRequest([
"fileName" => $fileName,
"md5" => $fileMd5,
"sizeInBytes" => $fileSize
]);
$runtime = new RuntimeOptions([]);
return $client->applyFileUploadLeaseWithOptions($categoryId, $workspaceId, $applyFileUploadLeaseRequest, $headers, $runtime);
}

/**
* 上传文件到临时存储。
*
* @param string $preSignedUrl 上传租约中的 URL。
* @param array $headers 上传请求的头部。
* @param string $filePath 文件本地路径。
*/
public static function uploadFile($preSignedUrl, $headers, $filePath) {
$fileContent = file_get_contents($filePath);
// 设置上传请求头
$uploadHeaders = [
"X-bailian-extra" => $headers["X-bailian-extra"],
"Content-Type" => $headers["Content-Type"]
];
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $preSignedUrl);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_POSTFIELDS, $fileContent);
curl_setopt($ch, CURLOPT_HTTPHEADER, array_map(function($key, $value) {
return "$key: $value";
}, array_keys($uploadHeaders), $uploadHeaders));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($httpCode != 200) {
throw new Exception("上传失败: " . curl_error($ch));
}
curl_close($ch);
}

/**
* 将文件添加到类目中。
*
* @param Bailian $client 客户端（Client）。
* @param string $leaseId 租约ID。
* @param string $parser 用于文件的解析器。
* @param string $categoryId 类目ID。
* @param string $workspaceId 业务空间ID。
* @return AddFileResponse 阿里云百炼服务的响应。
*/
public static function addFile($client, $leaseId, $parser, $categoryId, $workspaceId) {
$headers = [];
$addFileRequest = new AddFileRequest([
"leaseId" => $leaseId,
"parser" => $parser,
"categoryId" => $categoryId
]);
$runtime = new RuntimeOptions([]);
return $client->addFileWithOptions($workspaceId, $addFileRequest, $headers, $runtime);
}

/**
* 查询文件的基本信息。
*
* @param Bailian $client 客户端（Client）。
* @param string $workspaceId 业务空间ID。
* @param string $fileId 文件ID。
* @return DescribeFileResponse 阿里云百炼服务的响应。
*/
public static function describeFile($client, $workspaceId, $fileId) {
$headers = [];
$runtime = new RuntimeOptions([]);
return $client->describeFileWithOptions($workspaceId, $fileId, $headers, $runtime);
}

/**
* 在阿里云百炼服务中创建知识库（初始化）。
*
* @param Bailian $client 客户端（Client）。
* @param string $workspaceId 业务空间ID。
* @param string $fileId 文件ID。
* @param string $name 知识库名称。
* @param string $structureType 知识库的数据类型。
* @param string $sourceType 应用数据的数据类型，支持类目类型和文件类型。
* @param string $sinkType 知识库的向量存储类型。
* @return CreateIndexResponse 阿里云百炼服务的响应。
*/
public static function createIndex($client, $workspaceId, $fileId, $name, $structureType, $sourceType, $sinkType) {
$headers = [];
$createIndexRequest = new CreateIndexRequest([
"structureType" => $structureType,
"name" => $name,
"sourceType" => $sourceType,
"documentIds" => [
$fileId
],
"sinkType" => $sinkType
]);
$runtime = new RuntimeOptions([]);
return $client->createIndexWithOptions($workspaceId, $createIndexRequest, $headers, $runtime);
}

/**
* 向阿里云百炼服务提交索引任务。
*
* @param Bailian $client 客户端（Client）。
* @param string $workspaceId 业务空间ID。
* @param string $indexId 知识库ID。
* @return SubmitIndexJobResponse 阿里云百炼服务的响应。
*/
public static function submitIndex($client, $workspaceId, $indexId) {
$headers = [];
$submitIndexJobRequest = new SubmitIndexJobRequest([
'indexId' => $indexId
]);
$runtime = new RuntimeOptions([]);
return $client->submitIndexJobWithOptions($workspaceId, $submitIndexJobRequest, $headers, $runtime);
}

/**
* 查询索引任务状态。
*
* @param Bailian $client 客户端（Client）。
* @param string $workspaceId 业务空间ID。
* @param string $indexId 知识库ID。
* @param string $jobId 任务ID。
* @return GetIndexJobStatusResponse 阿里云百炼服务的响应。
*/
public static function getIndexJobStatus($client, $workspaceId, $jobId, $indexId) {
$headers = [];
$getIndexJobStatusRequest = new GetIndexJobStatusRequest([
'indexId' => $indexId,
'jobId' => $jobId
]);
$runtime = new RuntimeOptions([]);
return $client->getIndexJobStatusWithOptions($workspaceId, $getIndexJobStatusRequest, $headers, $runtime);
}

/**
* 使用阿里云百炼服务创建知识库。
*
* @param string $filePath 文件本地路径。
* @param string $workspaceId 业务空间ID。
* @param string $name 知识库名称。
* @return string|null 如果成功，返回知识库ID；否则返回null。
*/
public static function createKnowledgeBase($filePath, $workspaceId, $name) {
// 设置默认值
$categoryId = 'default';
$parser = 'DASHSCOPE_DOCMIND';
$sourceType = 'DATA_CENTER_FILE';
$structureType = 'unstructured';
$sinkType = 'DEFAULT';
try {
// 步骤1：初始化客户端（Client）
echo "步骤1：初始化Client\n";
$client = self::createClient();

// 步骤2：准备文件信息
echo "步骤2：准备文件信息\n";
$fileName = basename($filePath);
echo("this is filename : $fileName");
$fileMd5 = self::calculateMd5($filePath);
$fileSize = self::getFileSize($filePath);

// 步骤3：申请上传租约
echo "步骤3：向阿里云百炼申请上传租约\n";
$leaseResponse = self::applyLease($client, $categoryId, $fileName, $fileMd5, $fileSize, $workspaceId);
$leaseId = $leaseResponse->body->data->fileUploadLeaseId;
$uploadUrl = $leaseResponse->body->data->param->url;
$uploadHeaders = $leaseResponse->body->data->param->headers;
$uploadHeadersMap = json_decode(json_encode($uploadHeaders), true);

// 步骤4：上传文件
echo "步骤4：上传文件到阿里云百炼\n";
self::uploadFile($uploadUrl, $uploadHeadersMap, $filePath);

// 步骤5：将文件添加到服务器
echo "步骤5：将文件添加到阿里云百炼服务器\n";
$addResponse = self::addFile($client, $leaseId, $parser, $categoryId, $workspaceId);
$fileId = $addResponse->body->data->fileId;
echo("fileid: $fileId\n");
// 步骤6：检查文件状态
echo "步骤6：检查阿里云百炼中的文件状态\n";
while (true) {
$describeResponse = self::describeFile($client, $workspaceId, $fileId);
$status = $describeResponse->body->data->status;
echo "当前文件状态：$status\n";
if ($status == 'INIT') {
echo "文件待解析，请稍候...\n";
} elseif ($status == 'PARSING') {
echo "文件解析中，请稍候...\n";
} elseif ($status == 'PARSE_SUCCESS') {
echo "文件解析完成！\n";
break;
} else {
echo "未知的文件状态：$status, 请联系技术支持。\n";
return null;
}
sleep(5);
}

// 步骤7：初始化知识库
echo "步骤7：在阿里云百炼中初始化知识库\n";
$indexResponse = self::createIndex($client, $workspaceId, $fileId, $name, $structureType, $sourceType, $sinkType);
$indexId = $indexResponse->body->data->id;

// 步骤8：提交索引任务
echo "步骤8：向阿里云百炼提交索引任务\n";
$submitResponse = self::submitIndex($client, $workspaceId, $indexId);
$jobId = $submitResponse->body->data->id;

// 步骤9：获取索引任务状态
echo "步骤9：获取阿里云百炼索引任务状态\n";
while (true) {
$getIndexJobStatusResponse = self::getIndexJobStatus($client, $workspaceId, $jobId, $indexId);
$status = $getIndexJobStatusResponse->body->data->status;
echo "当前索引任务状态：$status\n";
if ($status == 'COMPLETED') {
break;
}
sleep(5);
}
echo "阿里云百炼知识库创建成功！\n";
return $indexId;
} catch (Exception $e) {
echo "发生错误：{$e->getMessage()}\n";
return null;
}
}

/**
* 主函数。
*/
public static function main($args){
if (!self::checkEnvironmentVariables()) {
echo "环境变量校验未通过。\n";
return;
}
$filePath = readline("请输入您需要上传文件的实际本地路径（以Linux为例：/xxx/xxx/阿里云百炼系列手机产品介绍.docx）：");
$kbName = readline("请为您的知识库输入一个名称：");
$workspaceId = getenv('WORKSPACE_ID');
$result = self::createKnowledgeBase($filePath, $workspaceId, $kbName);
if ($result) {
echo "知识库ID: $result\n";
} else {
echo "知识库创建失败。\n";
}
}
}
// 假定autoload.php位于当前代码文件所在目录的上一级目录中，请根据您的项目实际结构调整。
$path = __DIR__ . \DIRECTORY_SEPARATOR . '..' . \DIRECTORY_SEPARATOR . 'vendor' . \DIRECTORY_SEPARATOR . 'autoload.php';
if (file_exists($path)) {
require_once $path;
}
KnowledgeBaseCreate::main(array_slice($argv, 1));

// 示例代码仅供参考，请勿在生产环境中直接使用
'use strict';

const fs = require('fs');
const path = require('path');
const axios = require('axios');
const crypto = require('crypto');

const bailian20231229 = require('@alicloud/bailian20231229');
const OpenApi = require('@alicloud/openapi-client');
const Util = require('@alicloud/tea-util');
const Tea = require('@alicloud/tea-typescript');

class KbCreate {

/**
* 检查并提示设置必要的环境变量
* @returns {boolean} - 如果所有必需的环境变量都已设置，返回 true；否则返回 false
*/
static checkEnvironmentVariables() {
const requiredVars = {
'ALIBABA_CLOUD_ACCESS_KEY_ID': '阿里云访问密钥ID',
'ALIBABA_CLOUD_ACCESS_KEY_SECRET': '阿里云访问密钥密码',
'WORKSPACE_ID': '阿里云百炼业务空间ID'
};

const missing = [];
for (const [varName, desc] of Object.entries(requiredVars)) {
if (!process.env[varName]) {
console.error(`错误：请设置 ${varName} 环境变量 (${desc})`);
missing.push(varName);
}
}
return missing.length === 0;
}

/**
* 计算文件的MD5值
* @param {string} filePath - 文件本地路径
* @returns {Promise<string>} - 文件的MD5值
*/
static async calculateMD5(filePath) {
const hash = crypto.createHash('md5');
const stream = fs.createReadStream(filePath);

return new Promise((resolve, reject) => {
stream.on('data', chunk => hash.update(chunk));
stream.on('end', () => resolve(hash.digest('hex')));
stream.on('error', reject);
});
}

/**
* 获取文件大小（以字节为单位），返回字符串格式
* @param {string} filePath - 文件本地路径
* @returns {string} - 文件大小（如 "123456"）
*/
static getFileSize(filePath) {
try {
const stats = fs.statSync(filePath);
return stats.size.toString();
} catch (err) {
console.error(`获取文件大小失败: ${err.message}`);
throw err;
}
}

/**
* 创建并配置客户端（Client）
* @return Client
* @throws Exception
*/
static createClient() {
const config = new OpenApi.Config({
accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID,
accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET
});
// 下方接入地址以公有云的公网接入地址为例，可按需更换接入地址
config.endpoint = `bailian.cn-beijing.aliyuncs.com`;
return new bailian20231229.default(config);
}

/**
* 申请文件上传租约
* @param {Bailian20231229Client} client - 客户端（Client）
* @param {string} categoryId - 类目ID
* @param {string} fileName - 文件名称
* @param {string} fileMd5 - 文件的MD5值
* @param {string} fileSize - 文件大小（以字节为单位）
* @param {string} workspaceId - 业务空间ID
* @returns {Promise<bailian20231229.ApplyFileUploadLeaseResponse>} - 阿里云百炼服务的响应
*/
static async applyLease(client, categoryId, fileName, fileMd5, fileSize, workspaceId) {
const headers = {};
const req = new bailian20231229.ApplyFileUploadLeaseRequest({
md5: fileMd5,
fileName,
sizeInBytes: fileSize
});
const runtime = new Util.RuntimeOptions({});
return await client.applyFileUploadLeaseWithOptions(
categoryId,
workspaceId,
req,
headers,
runtime
);
}

/**
* 上传文件到临时存储
* @param {string} preSignedUrl - 上传租约中的URL
* @param {Object} headers - 上传请求的头部
* @param {string} filePath - 文件本地路径
*/
static async uploadFile(preSignedUrl, headers, filePath) {
const uploadHeaders = {
"X-bailian-extra": headers["X-bailian-extra"],
"Content-Type": headers["Content-Type"]
};
const stream = fs.createReadStream(filePath);
try {
await axios.put(preSignedUrl, stream, { headers: uploadHeaders });
} catch (e) {
throw new Error(`上传失败: ${e.message}`);
}
}

/**
* 添加文件到类目中
* @param {Bailian20231229Client} client - 客户端（Client）
* @param {string} leaseId - 租约ID
* @param {string} parser - 用于文件的解析器
* @param {string} categoryId - 类目ID
* @param {string} workspaceId - 业务空间ID
* @returns {Promise<bailian20231229.AddFileResponse>} - 阿里云百炼服务的响应
*/
static async addFile(client, leaseId, parser, categoryId, workspaceId) {
const headers = {};
const req = new bailian20231229.AddFileRequest({
leaseId,
parser,
categoryId
});
const runtime = new Util.RuntimeOptions({});
return await client.addFileWithOptions(workspaceId, req, headers, runtime);
}

/**
* 查询文件的解析状态
* @param {Bailian20231229Client} client - 客户端（Client）
* @param {string} workspaceId - 业务空间ID
* @param {string} fileId - 文件ID
* @returns {Promise<bailian20231229.DescribeFileResponse>} - 阿里云百炼服务的响应
*/
static async describeFile(client, workspaceId, fileId) {
const headers = {};
const runtime = new Util.RuntimeOptions({});
return await client.describeFileWithOptions(workspaceId, fileId, headers, runtime);
}

/**
* 初始化知识库（索引）
* @param {Bailian20231229Client} client - 客户端（Client）
* @param {string} workspaceId - 业务空间ID
* @param {string} fileId - 文件ID
* @param {string} name - 知识库名称
* @param {string} structureType - 知识库的数据类型
* @param {string} sourceType - 应用数据的数据类型，支持类目类型和文件类型
* @param {string} sinkType - 知识库的向量存储类型
* @returns {Promise<bailian20231229.CreateIndexResponse>} - 阿里云百炼服务的响应
*/
static async createIndex(client, workspaceId, fileId, name, structureType, sourceType, sinkType) {
const headers = {};
const req = new bailian20231229.CreateIndexRequest({
name,
structureType,
documentIds: [fileId],
sourceType,
sinkType
});
const runtime = new Util.RuntimeOptions({});
return await client.createIndexWithOptions(workspaceId, req, headers, runtime);
}

/**
* 提交索引任务
* @param {Bailian20231229Client} client - 客户端（Client）
* @param {string} workspaceId - 业务空间ID
* @param {string} indexId - 知识库ID
* @returns {Promise<bailian20231229.SubmitIndexJobResponse>} - 阿里云百炼服务的响应
*/
static async submitIndex(client, workspaceId, indexId) {
const headers = {};
const req = new bailian20231229.SubmitIndexJobRequest({ indexId });
const runtime = new Util.RuntimeOptions({});
return await client.submitIndexJobWithOptions(workspaceId, req, headers, runtime);
}

/**
* 查询索引任务状态
* @param {Bailian20231229Client} client - 客户端（Client）
* @param {string} workspaceId - 业务空间ID
* @param {string} jobId - 任务ID
* @param {string} indexId - 知识库ID
* @returns {Promise<bailian20231229.GetIndexJobStatusResponse>} - 阿里云百炼服务的响应
*/
static async getIndexJobStatus(client, workspaceId, jobId, indexId) {
const headers = {};
const req = new bailian20231229.GetIndexJobStatusRequest({ jobId, indexId });
const runtime = new Util.RuntimeOptions({});
return await client.getIndexJobStatusWithOptions(workspaceId, req, headers, runtime);
}

/**
* 创建知识库
* @param {string} filePath - 文件本地路径
* @param {string} workspaceId - 业务空间ID
* @param {string} name - 知识库名称
* @returns {Promise<string | null>} - 如果成功，返回知识库ID；否则返回null
*/
static async createKnowledgeBase(filePath, workspaceId, name) {
const categoryId = 'default';
const parser = 'DASHSCOPE_DOCMIND';
const sourceType = 'DATA_CENTER_FILE';
const structureType = 'unstructured';
const sinkType = 'DEFAULT';

try {
console.log("步骤1：初始化Client");
const client = this.createClient();

console.log("步骤2：准备文件信息");
const fileName = path.basename(filePath);
const fileMd5 = await this.calculateMD5(filePath);
const fileSize = this.getFileSize(filePath);

console.log("步骤3：向阿里云百炼申请上传租约")
const leaseRes = await this.applyLease(client, categoryId, fileName, fileMd5, fileSize, workspaceId);
const leaseId = leaseRes.body.data.fileUploadLeaseId;
const uploadUrl = leaseRes.body.data.param.url;
const uploadHeaders = leaseRes.body.data.param.headers;

console.log("步骤4：上传文件到阿里云百炼")
await this.uploadFile(uploadUrl, uploadHeaders, filePath);

console.log("步骤5：将文件添加到阿里云百炼服务器")
const addRes = await this.addFile(client, leaseId, parser, categoryId, workspaceId);
const fileId = addRes.body.data.fileId;

console.log("步骤6：检查阿里云百炼中的文件状态")
while (true) {
const descRes = await this.describeFile(client, workspaceId, fileId);
const status = descRes.body.data.status;
console.log(`当前文件状态：${status}`);

if (status === 'INIT') console.log("文件待解析，请稍候...");
else if (status === 'PARSING') console.log("文件解析中，请稍候...");
else if (status === 'PARSE_SUCCESS') break;
else {
console.error(`未知的文件状态：${status}，请联系技术支持。`);
return null;
}
await this.sleep(5);
}

console.log("步骤7：在阿里云百炼中初始化知识库")
const indexRes = await this.createIndex(client, workspaceId, fileId, name, structureType, sourceType, sinkType);
const indexId = indexRes.body.data.id;

console.log("步骤8：向阿里云百炼提交索引任务")
const submitRes = await this.submitIndex(client, workspaceId, indexId);
const jobId = submitRes.body.data.id;

console.log("步骤9：获取阿里云百炼索引任务状态")
while (true) {
const jobRes = await this.getIndexJobStatus(client, workspaceId, jobId, indexId);
const status = jobRes.body.data.status;
console.log(`当前索引任务状态：${status}`);
if (status === 'COMPLETED') break;
await this.sleep(5);
}
console.log("阿里云百炼知识库创建成功！");
return indexId;
} catch (e) {
console.error(`发生错误：${e.message}`);
return null;
}
}

/**
* 等待指定时间（秒）
* @param {number} seconds - 等待时间（秒）
* @returns {Promise<void>}
*/
static sleep(seconds) {
return new Promise(resolve => setTimeout(resolve, seconds * 1000));
}

static async main(args) {
if (!this.checkEnvironmentVariables()) {
console.log("环境变量校验未通过。");
return;
}

const readline = require('readline').createInterface({
input: process.stdin,
output: process.stdout
});

try {
const filePath = await new Promise((resolve, reject) => {
readline.question("请输入您需要上传文件的实际本地路径（以Linux为例：/xxx/xxx/阿里云百炼系列手机产品介绍.docx）：", (ans) => {
ans.trim() ? resolve(ans) : reject(new Error("路径不能为空"));
});
});
const kbName = await new Promise((resolve, reject) => {
readline.question("请为您的知识库输入一个名称：", (ans) => {
ans.trim() ? resolve(ans) : reject(new Error("知识库名称不能为空"));
});
});
const workspaceId = process.env.WORKSPACE_ID;

const result = await KbCreate.createKnowledgeBase(filePath, workspaceId, kbName);
if (result) console.log(`知识库ID: ${result}`);
else console.log("知识库创建失败。");
} catch (err) {
console.error(err.message);
} finally {
readline.close();
}
}
}

exports.KbCreate = KbCreate;
KbCreate.main(process.argv.slice(2));

// 示例代码仅供参考，请勿在生产环境中直接使用
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

using Newtonsoft.Json;
using Tea;
using Tea.Utils;

namespace AlibabaCloud.SDK.KnowledgeBase
{
public class KnowledgeBaseCreate
{
/// <summary>
/// 检查并提示设置必要的环境变量。
/// </summary>
/// <returns>如果所有必需的环境变量都已设置，返回 true；否则返回 false。</returns>
public static bool CheckEnvironmentVariables()
{
var requiredVars = new Dictionary<string, string>
{
{ "ALIBABA_CLOUD_ACCESS_KEY_ID", "阿里云访问密钥ID" },
{ "ALIBABA_CLOUD_ACCESS_KEY_SECRET", "阿里云访问密钥密码" },
{ "WORKSPACE_ID", "阿里云百炼业务空间ID" }
};

var missingVars = new List<string>();
foreach (var entry in requiredVars)
{
string value = Environment.GetEnvironmentVariable(entry.Key);
if (string.IsNullOrEmpty(value))
{
missingVars.Add(entry.Key);
Console.WriteLine($"错误：请设置 {entry.Key} 环境变量（{entry.Value}）");
}
}

return missingVars.Count == 0;
}

/// <summary>
/// 计算文件的MD5值。
/// </summary>
/// <param name="filePath">文件本地路径</param>
/// <returns>文件的MD5值</returns>
/// <exception cref="Exception">计算过程中发生错误时抛出异常</exception>
public static string CalculateMD5(string filePath)
{
using (var md5 = MD5.Create())
{
using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
byte[] hashBytes = md5.ComputeHash(stream);
StringBuilder sb = new StringBuilder();
foreach (byte b in hashBytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
}

/// <summary>
/// 获取文件大小（以字节为单位）。
/// </summary>
/// <param name="filePath">文件本地路径</param>
/// <returns>文件大小（以字节为单位）</returns>
public static string GetFileSize(string filePath)
{
var file = new FileInfo(filePath);
return file.Length.ToString();
}

/// <summary>
/// 初始化客户端（Client）。
/// </summary>
/// <returns>配置好的客户端对象</returns>
/// <exception cref="Exception">初始化过程中发生错误时抛出异常</exception>
public static AlibabaCloud.SDK.Bailian20231229.Client CreateClient()
{
var config = new AlibabaCloud.OpenApiClient.Models.Config
{
AccessKeyId = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ACCESS_KEY_ID"),
AccessKeySecret = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ACCESS_KEY_SECRET"),
};
// 下方接入地址以公有云的公网接入地址为例，可按需更换接入地址.
config.Endpoint = "bailian.cn-beijing.aliyuncs.com";
return new AlibabaCloud.SDK.Bailian20231229.Client(config);
}

/// <summary>
/// 申请文件上传租约。
/// </summary>
/// <param name="client">客户端对象</param>
/// <param name="categoryId">类目ID</param>
/// <param name="fileName">文件名称</param>
/// <param name="fileMd5">文件的MD5值</param>
/// <param name="fileSize">文件大小（以字节为单位）</param>
/// <param name="workspaceId">业务空间ID</param>
/// <returns>阿里云百炼服务的响应对象</returns>
/// <exception cref="Exception">调用过程中发生错误时抛出异常</exception>
public static AlibabaCloud.SDK.Bailian20231229.Models.ApplyFileUploadLeaseResponse ApplyLease(
AlibabaCloud.SDK.Bailian20231229.Client client,
string categoryId,
string fileName,
string fileMd5,
string fileSize,
string workspaceId)
{
var headers = new Dictionary<string, string>() { };
var applyFileUploadLeaseRequest = new AlibabaCloud.SDK.Bailian20231229.Models.ApplyFileUploadLeaseRequest
{
FileName = fileName,
Md5 = fileMd5,
SizeInBytes = fileSize
};
var runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
return client.ApplyFileUploadLeaseWithOptions(categoryId, workspaceId, applyFileUploadLeaseRequest, headers, runtime);
}

/// <summary>
/// 上传文件到临时存储。
/// </summary>
/// <param name="preSignedUrl">上传租约中的 URL</param>
/// <param name="headers">上传请求的头部</param>
/// <param name="filePath">文件本地路径</param>
/// <exception cref="Exception">上传过程中发生错误时抛出异常</exception>
public static void UploadFile(string preSignedUrl, Dictionary<string, string> headers, string filePath)
{
var file = new FileInfo(filePath);
if (!File.Exists(filePath))
{
throw new ArgumentException($"文件不存在或不是普通文件: {filePath}");
}

using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
var url = new Uri(preSignedUrl);
var conn = (HttpWebRequest)WebRequest.Create(url);
conn.Method = "PUT";
conn.ContentType = headers["Content-Type"];
conn.Headers.Add("X-bailian-extra", headers["X-bailian-extra"]);

byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = fs.Read(buffer, 0, buffer.Length)) > 0)
{
conn.GetRequestStream().Write(buffer, 0, bytesRead);
}

using (var response = (HttpWebResponse)conn.GetResponse())
{
if (response.StatusCode != HttpStatusCode.OK)
{
throw new Exception($"上传失败: {response.StatusCode}");
}
}
}
}

/// <summary>
/// 将文件添加到类目中。
/// </summary>
/// <param name="client">客户端对象</param>
/// <param name="leaseId">租约ID</param>
/// <param name="parser">用于文件的解析器</param>
/// <param name="categoryId">类目ID</param>
/// <param name="workspaceId">业务空间ID</param>
/// <returns>阿里云百炼服务的响应对象</returns>
/// <exception cref="Exception">调用过程中发生错误时抛出异常</exception>
public static AlibabaCloud.SDK.Bailian20231229.Models.AddFileResponse AddFile(
AlibabaCloud.SDK.Bailian20231229.Client client,
string leaseId,
string parser,
string categoryId,
string workspaceId)
{
var headers = new Dictionary<string, string>() { };
var addFileRequest = new AlibabaCloud.SDK.Bailian20231229.Models.AddFileRequest
{
LeaseId = leaseId,
Parser = parser,
CategoryId = categoryId
};
var runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
return client.AddFileWithOptions(workspaceId, addFileRequest, headers, runtime);
}

/// <summary>
/// 查询文件的基本信息。
/// </summary>
/// <param name="client">客户端对象</param>
/// <param name="workspaceId">业务空间ID</param>
/// <param name="fileId">文件ID</param>
/// <returns>阿里云百炼服务的响应对象</returns>
/// <exception cref="Exception">调用过程中发生错误时抛出异常</exception>
public static AlibabaCloud.SDK.Bailian20231229.Models.DescribeFileResponse DescribeFile(
AlibabaCloud.SDK.Bailian20231229.Client client,
string workspaceId,
string fileId)
{
var headers = new Dictionary<string, string>() { };
var runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
return client.DescribeFileWithOptions(workspaceId, fileId, headers, runtime);
}

/// <summary>
/// 在阿里云百炼服务中创建知识库（初始化）。
/// </summary>
/// <param name="client">客户端对象</param>
/// <param name="workspaceId">业务空间ID</param>
/// <param name="fileId">文件ID</param>
/// <param name="name">知识库名称</param>
/// <param name="structureType">知识库的数据类型</param>
/// <param name="sourceType">应用数据的数据类型，支持类目类型和文件类型</param>
/// <param name="sinkType">知识库的向量存储类型</param>
/// <returns>阿里云百炼服务的响应对象</returns>
/// <exception cref="Exception">调用过程中发生错误时抛出异常</exception>
public static AlibabaCloud.SDK.Bailian20231229.Models.CreateIndexResponse CreateIndex(
AlibabaCloud.SDK.Bailian20231229.Client client,
string workspaceId,
string fileId,
string name,
string structureType,
string sourceType,
string sinkType)
{
var headers = new Dictionary<string, string>() { };
var createIndexRequest = new AlibabaCloud.SDK.Bailian20231229.Models.CreateIndexRequest
{
StructureType = structureType,
Name = name,
SourceType = sourceType,
SinkType = sinkType,
DocumentIds = new List<string> { fileId }
};
var runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
return client.CreateIndexWithOptions(workspaceId, createIndexRequest, headers, runtime);
}

/// <summary>
/// 向阿里云百炼服务提交索引任务。
/// </summary>
/// <param name="client">客户端对象</param>
/// <param name="workspaceId">业务空间ID</param>
/// <param name="indexId">知识库ID</param>
/// <returns>阿里云百炼服务的响应对象</returns>
/// <exception cref="Exception">调用过程中发生错误时抛出异常</exception>
public static AlibabaCloud.SDK.Bailian20231229.Models.SubmitIndexJobResponse SubmitIndex(
AlibabaCloud.SDK.Bailian20231229.Client client,
string workspaceId,
string indexId)
{
var headers = new Dictionary<string, string>() { };
var submitIndexJobRequest = new AlibabaCloud.SDK.Bailian20231229.Models.SubmitIndexJobRequest
{
IndexId = indexId
};
var runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
return client.SubmitIndexJobWithOptions(workspaceId, submitIndexJobRequest, headers, runtime);
}

/// <summary>
/// 查询索引任务状态。
/// </summary>
/// <param name="client">客户端对象</param>
/// <param name="workspaceId">业务空间ID</param>
/// <param name="jobId">任务ID</param>
/// <param name="indexId">知识库ID</param>
/// <returns>阿里云百炼服务的响应对象</returns>
/// <exception cref="Exception">调用过程中发生错误时抛出异常</exception>
public static AlibabaCloud.SDK.Bailian20231229.Models.GetIndexJobStatusResponse GetIndexJobStatus(
AlibabaCloud.SDK.Bailian20231229.Client client,
string workspaceId,
string jobId,
string indexId)
{
var headers = new Dictionary<string, string>() { };
var getIndexJobStatusRequest = new AlibabaCloud.SDK.Bailian20231229.Models.GetIndexJobStatusRequest
{
IndexId = indexId,
JobId = jobId
};
var runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
return client.GetIndexJobStatusWithOptions(workspaceId, getIndexJobStatusRequest, headers, runtime);
}

/// <summary>
/// 使用阿里云百炼服务创建知识库。
/// </summary>
/// <param name="filePath">文件本地路径</param>
/// <param name="workspaceId">业务空间ID</param>
/// <param name="name">知识库名称</param>
/// <returns>如果成功，返回知识库ID；否则返回 null</returns>
public static string CreateKnowledgeBase(string filePath, string workspaceId, string name)
{
// 设置默认值
string categoryId = "default";
string parser = "DASHSCOPE_DOCMIND";
string sourceType = "DATA_CENTER_FILE";
string structureType = "unstructured";
string sinkType = "DEFAULT";

try
{
Console.WriteLine("步骤1：初始化Client");
AlibabaCloud.SDK.Bailian20231229.Client client = CreateClient();

Console.WriteLine("步骤2：准备文件信息");
var fileInfo = new FileInfo(filePath);
string fileName = fileInfo.Name;
string fileMd5 = CalculateMD5(filePath);
string fileSize = GetFileSize(filePath);

Console.WriteLine("步骤3：向阿里云百炼申请上传租约");
Bailian20231229.Models.ApplyFileUploadLeaseResponse leaseResponse = ApplyLease(client, categoryId, fileName, fileMd5, fileSize, workspaceId);
string leaseId = leaseResponse.Body.Data.FileUploadLeaseId;
string uploadUrl = leaseResponse.Body.Data.Param.Url;
var uploadHeaders = leaseResponse.Body.Data.Param.Headers;

Console.WriteLine("步骤4：上传文件到阿里云百炼");
// 请自行安装Newtonsoft.Json
var uploadHeadersMap = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(uploadHeaders));
UploadFile(uploadUrl, uploadHeadersMap, filePath);

Console.WriteLine("步骤5：将文件添加到阿里云百炼服务器");
Bailian20231229.Models.AddFileResponse addResponse = AddFile(client, leaseId, parser, categoryId, workspaceId);
string fileId = addResponse.Body.Data.FileId;

Console.WriteLine("步骤6：检查阿里云百炼中的文件状态");
while (true)
{
Bailian20231229.Models.DescribeFileResponse describeResponse = DescribeFile(client, workspaceId, fileId);
string status = describeResponse.Body.Data.Status;
Console.WriteLine($"当前文件状态：{status}");

if (status == "INIT")
{
Console.WriteLine("文件待解析，请稍候...");
}
else if (status == "PARSING")
{
Console.WriteLine("文件解析中，请稍候...");
}
else if (status == "PARSE_SUCCESS")
{
Console.WriteLine("文件解析完成！");
break;
}
else
{
Console.WriteLine($"未知的文件状态：{status}，请联系技术支持。");
return null;
}
Thread.Sleep(5000);
}

Console.WriteLine("步骤7：在阿里云百炼中创建知识库");
Bailian20231229.Models.CreateIndexResponse indexResponse = CreateIndex(client, workspaceId, fileId, name, structureType, sourceType, sinkType);
string indexId = indexResponse.Body.Data.Id;

Console.WriteLine("步骤8：向阿里云百炼提交索引任务");
Bailian20231229.Models.SubmitIndexJobResponse submitResponse = SubmitIndex(client, workspaceId, indexId);
string jobId = submitResponse.Body.Data.Id;

Console.WriteLine("步骤9：获取阿里云百炼索引任务状态");
while (true)
{
Bailian20231229.Models.GetIndexJobStatusResponse getStatusResponse = GetIndexJobStatus(client, workspaceId, jobId, indexId);
string status = getStatusResponse.Body.Data.Status;
Console.WriteLine($"当前索引任务状态：{status}");

if (status == "COMPLETED")
{
break;
}
Thread.Sleep(5000);
}

Console.WriteLine("阿里云百炼知识库创建成功！");
return indexId;

}
catch (Exception ex)
{
Console.WriteLine($"发生错误：{ex.Message}");
Console.WriteLine("错误详情: " + ex.StackTrace);
return null;
}
}

/// <summary>
/// 主函数。
/// </summary>
public static void Main(string[] args)
{
if (!CheckEnvironmentVariables())
{
return;
}

Console.Write("请输入您需要上传文件的实际本地路径（以Linux为例：/xxx/xxx/阿里云百炼系列手机产品介绍.docx）：");
string filePath = Console.ReadLine();

Console.Write("请为您的知识库输入一个名称：");
string kbName = Console.ReadLine();

string workspaceId = Environment.GetEnvironmentVariable("WORKSPACE_ID");
string result = CreateKnowledgeBase(filePath, workspaceId, kbName);
if (result != null)
{
Console.WriteLine($"知识库ID: {result}");
}
}
}
}