插件-知识库

curl --location 'https://nlp.aliyuncs.com/v2/api/knowledge_base/create' \
--header 'Expect;' \
--header 'accept: */*' \
--header 'Content-Type: application/json' \
--header 'x-fag-servicename: aca-kb-create' \
--header 'x-fag-appcode: aca' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--data '{
            "name": "知识库名称",
            "description": "知识库描述"
        }'

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

/**
 * API名称：知识库创建
 * 环境要求：Java 17及以上
 */
public class Example {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/create";
    private static final String API_KEY = "Bearer {YOUR_API_KEY}";

    public static void main(String[] args) throws Exception {
        // 创建
        create();
    }

    private static void create() throws Exception {
        System.out.println("=== 知识库创建 ===");
        String jsonBody = """
            {
                "name": "知识库名称",
                "description": "知识库描述"
            }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        // 固定servicename
                        "x-fag-servicename", "aca-kb-create",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // 同步调用
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("响应数据: " + responseBody);
    }
}

import requests

URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/create"

# API名称：知识库创建
# 环境要求：python3.10及以上

# 创建
def create(api_key):
    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-kb-create",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}"
    }

    payload = {
        "name": "知识库名称",
        "description": "知识库描述"
    }

    response = requests.post(URL, json=payload, headers=headers)
    # 逐行打印原始响应内容
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # 检查响应状态，如有错误则抛出异常
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # 创建知识库
        response = create(api_key)
    except requests.HTTPError as e:
        print(f"请求出错: {e}")

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

// API名称：知识库创建
// 环境要求：go 1.20及以上

const URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/create"

// 创建知识库
func create(apiKey string) (*http.Response, error) {
    payload := map[string]interface{}{
        "name":        "知识库名称",
        "description": "知识库描述",
    }

    payloadBytes, err := json.Marshal(payload)
    if err != nil {
        return nil, err
    }

    req, err := http.NewRequest("POST", URL, bytes.NewBuffer(payloadBytes))
    if err != nil {
        return nil, err
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("x-fag-servicename", "aca-kb-create")
    req.Header.Set("x-fag-appcode", "aca")
    req.Header.Set("Authorization", "Bearer "+apiKey)
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }

    // 逐行打印原始响应内容
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("请求出错，状态码：%d", resp.StatusCode)
    }

    return resp, nil
}

func main() {

    apiKey := "YOUR_API_KEY"
    // 创建知识库
    _, err := create(apiKey)
    if err != nil {
        fmt.Printf("请求出错: %v\n", err)
    }
}

curl --location 'https://nlp.aliyuncs.com/v2/api/knowledge_base/update' \
--header 'Expect;' \
--header 'accept: */*' \
--header 'Content-Type: application/json' \
--header 'x-fag-servicename: aca-kb-update' \
--header 'x-fag-appcode: aca' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--data '{
            "knowledgeBaseId": "知识库id",
            "name": "知识库名称",
            "description": "知识库描述"
        }'

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

/**
 * API名称：知识库修改
 * 环境要求：Java 17及以上
 */
public class Example {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/update";
    private static final String API_KEY = "Bearer {YOUR_API_KEY}";

    public static void main(String[] args) throws Exception {
        // 修改
        update();
    }

    private static void update() throws Exception {
        System.out.println("=== 知识库修改 ===");
        String jsonBody = """
            {
             "knowledgeBaseId": "替换knowledgeBaseId",
             "name": "知识库名称修改",
             "description": "知识库描述修改"
            }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        // 固定servicename
                        "x-fag-servicename", "aca-kb-update",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // 同步调用
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("响应数据: " + responseBody);
    }
}

import requests

URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/update"

# API名称：知识库修改
# 环境要求：python3.10及以上

# 修改
def update(api_key):
    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-kb-update",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}"
    }

    payload = {
        "knowledgeBaseId": "YOUR_KNOW_ID",
        "name": "知识库名称3",
        "description": "知识库描述3"
    }

    response = requests.post(URL, json=payload, headers=headers)
    # 逐行打印原始响应内容
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # 检查响应状态，如有错误则抛出异常
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # 修改知识库
        response = update(api_key)
    except requests.HTTPError as e:
        print(f"请求出错: {e}")

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

// API名称：知识库修改
// 环境要求：go 1.20及以上

const URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/update"

// 修改知识库
func update(apiKey string) (*http.Response, error) {
    payload := map[string]interface{}{
        "knowledgeBaseId": "替换knowledgeBaseId",
        "name":            "知识库名称",
        "description":     "知识库描述",
    }

    payloadBytes, err := json.Marshal(payload)
    if err != nil {
        return nil, err
    }

    req, err := http.NewRequest("POST", URL, bytes.NewBuffer(payloadBytes))
    if err != nil {
        return nil, err
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("x-fag-servicename", "aca-kb-update")
    req.Header.Set("x-fag-appcode", "aca")
    req.Header.Set("Authorization", "Bearer "+apiKey)
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }

    // 逐行打印原始响应内容
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("请求出错，状态码：%d", resp.StatusCode)
    }

    return resp, nil
}

func main() {

    // 修改知识库
    _, err := update(apiKey)
    if err != nil {
        fmt.Printf("请求出错: %v\n", err)
    }
}

curl --location 'https://nlp.aliyuncs.com/v2/api/knowledge_base/search' \
--header 'Expect;' \
--header 'accept: */*' \
--header 'Content-Type: application/json' \
--header 'x-fag-servicename: aca-kb-search' \
--header 'x-fag-appcode: aca' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--data '{
            "pageNum": 1,
            "pageSize": 10
        }'

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

/**
 * API名称：知识库查询
 * 环境要求：Java 17及以上
 */
public class Example {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/search";
    private static final String API_KEY = "Bearer {YOUR_API_KEY}";

    public static void main(String[] args) throws Exception {
        // 查询
        search();
    }

    private static void search() throws Exception {
        System.out.println("=== 知识库查询 ===");
        String jsonBody = """
            {
                "pageNum": 1,
                "pageSize": 10
            }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        // 固定servicename
                        "x-fag-servicename", "aca-kb-search",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // 同步调用
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("响应数据: " + responseBody);
    }
}

import requests

URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/search"

# API名称：知识库查询
# 环境要求：python3.10及以上

# 查询
def search(api_key):
    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename":"aca-kb-search",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}"
    }

    payload = {
        "pageNum": 1,
        "pageSize": 10
    }

    response = requests.post(URL, json=payload, headers=headers)
    # 逐行打印原始响应内容
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # 检查响应状态，如有错误则抛出异常
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # 查询知识库
        response = search(api_key)
    except requests.HTTPError as e:
        print(f"请求出错: {e}")

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

// API名称：知识库查询
// 环境要求：go 1.20及以上

const URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/search"



// 查询知识库
func search(apiKey string) (*http.Response, error) {
    payload := map[string]interface{}{
        "pageNum":  1,
        "pageSize": 10,
    }

    payloadBytes, err := json.Marshal(payload)
    if err != nil {
        return nil, err
    }

    req, err := http.NewRequest("POST", URL, bytes.NewBuffer(payloadBytes))
    if err != nil {
        return nil, err
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("x-fag-servicename", "aca-kb-search")
    req.Header.Set("x-fag-appcode", "aca")
    req.Header.Set("Authorization", "Bearer "+apiKey)
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }

    // 逐行打印原始响应内容
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("请求出错，状态码：%d", resp.StatusCode)
    }

    return resp, nil
}

func main() {

    apiKey := "YOUR_API_KEY"
    // 查询知识库
    _, err := search(apiKey)
    if err != nil {
        fmt.Printf("请求出错: %v\n", err)
    }
}

curl --location 'https://nlp.aliyuncs.com/v2/api/knowledge_base/delete' \
--header 'Expect;' \
--header 'accept: */*' \
--header 'Content-Type: application/json' \
--header 'x-fag-servicename: aca-kb-delete' \
--header 'x-fag-appcode: aca' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--data '{
            "knowledgeBaseId": "知识库id"
        }'

/**
 * API名称：知识库删除
 * 环境要求：Java 17及以上
 */
public class Example {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/delete";
    private static final String API_KEY = "Bearer {YOUR_API_KEY}";

    public static void main(String[] args) throws Exception {
       // 删除
       delete();
    }
    private static void delete() throws Exception {
        System.out.println("=== 知识库删除 ===");
        String jsonBody = """
            {
                "knowledgeBaseId": "替换knowledgeBaseId"
            }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        // 固定servicename
                        "x-fag-servicename", "aca-kb-delete",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // 同步调用
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("响应数据: " + responseBody);
    }
}

import requests

URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/delete"

# API名称：知识库删除
# 环境要求：python3.10及以上

# 删除
def delete(api_key):
    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-kb-delete",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}"
    }

    payload = {
        "knowledgeBaseId": "YOUR_KNOW_ID"
    }

    response = requests.post(URL, json=payload, headers=headers)
    # 逐行打印原始响应内容
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # 检查响应状态，如有错误则抛出异常
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # 删除知识库
        response = delete(api_key)
    except requests.HTTPError as e:
        print(f"请求出错: {e}")

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

// API名称：知识库删除
// 环境要求：go 1.20及以上

const URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/delete"

// 删除
func delete(apiKey string) (*http.Response, error) {
    payload := map[string]interface{}{
        "knowledgeBaseId": "替换knowledgeBaseId",
    }

    payloadBytes, err := json.Marshal(payload)
    if err != nil {
        return nil, err
    }

    req, err := http.NewRequest("POST", URL, bytes.NewBuffer(payloadBytes))
    if err != nil {
        return nil, err
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("x-fag-servicename", "aca-kb-delete")
    req.Header.Set("x-fag-appcode", "aca")
    req.Header.Set("Authorization", "Bearer "+apiKey)
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }

    // 逐行打印原始响应内容
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("请求出错，状态码：%d", resp.StatusCode)
    }

    return resp, nil
}

func main() {

    apiKey := "YOUR_API_KEY"
    
    // 删除知识库
    _, err := delete(apiKey)
    if err != nil {
        fmt.Printf("请求出错: %v\n", err)
    }
}

curl --location 'https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/upload' \
--header 'Expect;' \
--header 'accept: */*' \
--header 'Content-Type: application/json' \
--header 'x-fag-servicename: aca-kb-detail-upload' \
--header 'x-fag-appcode: aca' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--data '{
            "knowledgeBaseId": "知识库id",
            "type": "text",
            "fileInfos": [
                {
                    "filename": "文件名.txt",
                    "fileUrl": "公网可访问地址"				
                }
            ]
        }'

/**
 * API名称：知识库文件上传
 * 环境要求：Java 17及以上
 */
public class Example {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/upload";
    private static final String API_KEY = "Bearer {YOUR_API_KEY}";

    public static void main(String[] args) throws Exception {
        // 上传
       upload();
    }

    private static void upload() throws Exception {
        System.out.println("=== 知识库文件上传 ===");
        String jsonBody = """
        {
         "knowledgeBaseId": "d1f5c2797e9e4e80ac7a6363c830d31a",
         "type": "text",
         "fileInfos": [
             {
                 "fileUrl": "https://lang.alicdn.com/xingchen/guanyu.txt",
                 "filename": "guanyu.txt"
             }
         ]
        }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        // 固定servicename
                        "x-fag-servicename", "aca-kb-detail-upload",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // 同步调用
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("响应数据: " + responseBody);
    }
}

import requests

URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/upload"

# API名称：知识库文件上传
# 环境要求：python3.10及以上

# 上传
def upload(api_key):
    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-kb-detail-upload",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}"
    }

    payload = {
        "knowledgeBaseId": "替换knowledgeBaseId",
        "type": "text",
        "fileInfos": [
            {
                "fileUrl": "https://lang.alicdn.com/xingchen/guanyu.txt",
                "filename": "guanyu3.txt"
            }
        ]
    }

    response = requests.post(URL, json=payload, headers=headers)
    # 逐行打印原始响应内容
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # 检查响应状态，如有错误则抛出异常
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # 上传知识库文件
        response = upload(api_key)
    except requests.HTTPError as e:
        print(f"请求出错: {e}")

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

// API名称：知识库文件上传
// 环境要求：go 1.20及以上

const URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/upload"

// 上传
func upload(apiKey string) (*http.Response, error) {
	payload := map[string]interface{}{
		"knowledgeBaseId": "替换knowledgeBaseId",
		"type":            "text",
		"fileInfos": []map[string]string{
			{
				"fileUrl":  "https://lang.alicdn.com/xingchen/guanyu.txt",
				"filename": "guanyu.txt",
			},
		},
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", URL, bytes.NewBuffer(payloadBytes))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("x-fag-servicename", "aca-kb-detail-upload")
	req.Header.Set("x-fag-appcode", "aca")
	req.Header.Set("Authorization", "Bearer "+apiKey)
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}

	// 逐行打印原始响应内容
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("请求出错，状态码：%d", resp.StatusCode)
	}

	return resp, nil
}

func main() {

	apiKey := "YOUR_API_KEY"
	// 上传
	_, err := upload(apiKey)
	if err != nil {
		fmt.Printf("请求出错: %v\n", err)
	}
}

curl --location 'https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/update' \
--header 'Expect;' \
--header 'accept: */*' \
--header 'Content-Type: application/json' \
--header 'x-fag-servicename: aca-kb-detail-update' \
--header 'x-fag-appcode: aca' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--data '{
            "knowledgeBaseId": "知识库id",
            "name": "现在使用的名称",
            "newName": "新的名称"
        }'

/**
 * API名称：知识库文件修改
 * 环境要求：Java 17及以上
 */
public class Example {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/update";
    private static final String API_KEY = "Bearer {YOUR_API_KEY}";

    public static void main(String[] args) throws Exception {
       // 修改
       update();

    }

    private static void update() throws Exception {
        System.out.println("=== 知识库文件名称修改 ===");
        // name 字段填写上方 filename
        String jsonBody = """
       {
           "knowledgeBaseId": "替换knowledgeBaseId",
           "name": "guanyu.txt",
           "newName": "newName.txt"
       }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        // 固定servicename
                        "x-fag-servicename", "aca-kb-detail-update",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // 同步调用
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("响应数据: " + responseBody);
    }
}

import requests

URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/update"

# API名称：知识库文件修改
# 环境要求：python3.10及以上

# 修改
def update(api_key):
    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-kb-detail-update",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}"
    }
    # name 填写上方filename
    payload = {
        "knowledgeBaseId": "替换knowledgeBaseId",
        "name": "guanyu.txt",
        "newName": "newName.txt"
    }

    response = requests.post(URL, json=payload, headers=headers)
    # 逐行打印原始响应内容
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # 检查响应状态，如有错误则抛出异常
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # 修改知识库文件
        response = update(api_key)
    except requests.HTTPError as e:
        print(f"请求出错: {e}")

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

// API名称：知识库文件修改
// 环境要求：go 1.20及以上

const URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/update"

// 修改知识库文件
func update(apiKey string) (*http.Response, error) {
	// name 填写上方filename
	payload := map[string]interface{}{
		"knowledgeBaseId": "替换knowledgeBaseId",
		"name":            "guanyu.txt",
		"newName":         "guanyu1.txt",
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", URL, bytes.NewBuffer(payloadBytes))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("x-fag-servicename", "aca-kb-detail-update")
	req.Header.Set("x-fag-appcode", "aca")
	req.Header.Set("Authorization", "Bearer "+apiKey)
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}

	// 逐行打印原始响应内容
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("请求出错，状态码：%d", resp.StatusCode)
	}

	return resp, nil
}

func main() {

	apiKey := "YOUR_API_KEY"
	
	// 修改知识库文件
	_, err := update(apiKey)
	if err != nil {
		fmt.Printf("请求出错: %v\n", err)
	}
}

curl --location 'https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/search' \
--header 'Expect;' \
--header 'accept: */*' \
--header 'Content-Type: application/json' \
--header 'x-fag-servicename: aca-kb-detail-search' \
--header 'x-fag-appcode: aca' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--data '{
            "knowledgeBaseId": "知识库id",
            "pageNum": 1,
            "pageSize": 10
        }'

/**
 * API名称：知识库文件查询
 * 环境要求：Java 17及以上
 */
public class Example {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/search";
    private static final String API_KEY = "Bearer {YOUR_API_KEY}";

    public static void main(String[] args) throws Exception {
        // 查询
        search();
    }

    private static void search() throws Exception {
        System.out.println("=== 知识库文件查询 ===");
        String jsonBody = """
        {
            "knowledgeBaseId": "替换knowledgeBaseId",
            "pageNum": 1,
            "pageSize": 10
        }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        // 固定servicename
                        "x-fag-servicename", "aca-kb-detail-search",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // 同步调用
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("响应数据: " + responseBody);
    }
}

import requests

URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/search"

# API名称：知识库文件查询
# 环境要求：python3.10及以上

# 查询
def search(api_key):
    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-kb-detail-search",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}"
    }

    payload = {
        "knowledgeBaseId": "替换knowledgeBaseId",
        "pageNum": 1,
        "pageSize": 10
    }

    response = requests.post(URL, json=payload, headers=headers)
    # 逐行打印原始响应内容
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # 检查响应状态，如有错误则抛出异常
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # 查询知识库文件
        response = search(api_key)
    except requests.HTTPError as e:
        print(f"请求出错: {e}")

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

// API名称：知识库文件查询
// 环境要求：go 1.20及以上

const URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/search"

// 查询知识库文件
func search(apiKey string) (*http.Response, error) {
	payload := map[string]interface{}{
		"knowledgeBaseId": "替换knowledgeBaseId",
		"pageNum":         1,
		"pageSize":        10,
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", URL, bytes.NewBuffer(payloadBytes))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("x-fag-servicename", "aca-kb-detail-search")
	req.Header.Set("x-fag-appcode", "aca")
	req.Header.Set("Authorization", "Bearer "+apiKey)
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}

	// 逐行打印原始响应内容
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("请求出错，状态码：%d", resp.StatusCode)
	}

	return resp, nil
}

func main() {

	apiKey := "YOUR_API_KEY"
	//查询知识库文件
	_, err := search(apiKey)
	if err != nil {
		fmt.Printf("请求出错: %v\n", err)
	}
}

curl --location 'https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/delete' \
--header 'Expect;' \
--header 'accept: */*' \
--header 'Content-Type: application/json' \
--header 'x-fag-servicename: aca-kb-detail-delete' \
--header 'x-fag-appcode: aca' \
--header 'Authorization: Bearer {YOUR_API_KEY}' \
--data '{
            "knowledgeBaseId": "知识库id",
            "name": "知识库详情名称"
        }'

/**
 * API名称：知识库文件删除等
 * 环境要求：Java 17及以上
 */
public class Example {
    private static final String URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/delete";
    private static final String API_KEY = "Bearer {YOUR_API_KEY}";

    public static void main(String[] args) throws Exception {
       // 删除
       delete();
    }

    private static void delete() throws Exception {
        System.out.println("=== 知识库文件删除 ===");
        String jsonBody = """
            {
                "knowledgeBaseId": "替换knowledgeBaseId",
                "name": "newName.txt"
            }
        """;

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(URL))
                .headers(
                        "Authorization", API_KEY,
                        // 固定servicename
                        "x-fag-servicename", "aca-kb-detail-delete",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // 同步调用
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("响应数据: " + responseBody);
    }
}

import requests

URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/delete"

# API名称：知识库文件删除
# 环境要求：python3.10及以上

# 删除
def delete(api_key):
    headers = {
        "Content-Type": "application/json",
        "x-fag-servicename": "aca-kb-detail-delete",
        "x-fag-appcode": "aca",
        "Authorization": f"Bearer {api_key}"
    }

    payload = {
        "knowledgeBaseId": "替换knowledgeBaseId",
        "name": "guanyu.txt"
    }

    response = requests.post(URL, json=payload, headers=headers)
    # 逐行打印原始响应内容
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # 检查响应状态，如有错误则抛出异常
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # 删除
        response = delete(api_key)
    except requests.HTTPError as e:
        print(f"请求出错: {e}")

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

// API名称：知识库文件删除
// 环境要求：go 1.20及以上

const URL = "https://nlp.aliyuncs.com/v2/api/knowledge_base/detail/delete"

// 删除
func delete(apiKey string) (*http.Response, error) {
	payload := map[string]interface{}{
		"knowledgeBaseId": "替换knowledgeBaseId",
		"name":            "guanyu.txt",
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", URL, bytes.NewBuffer(payloadBytes))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("x-fag-servicename", "aca-kb-detail-delete")
	req.Header.Set("x-fag-appcode", "aca")
	req.Header.Set("Authorization", "Bearer "+apiKey)
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}

	// 逐行打印原始响应内容
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("请求出错，状态码：%d", resp.StatusCode)
	}

	return resp, nil
}

func main() {

	apiKey := "YOUR_API_KEY"

	// 删除
	_, err := delete(apiKey)
	if err != nil {
		fmt.Printf("请求出错: %v\n", err)
	}
}