Plugin - Knowledge Base

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": "My Knowledge Base",
            "description": "Description of my knowledge base."
        }'

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

/**
 * API name: Create a knowledge base
 * Environment requirement: Java 17 or later
 */
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
        create();
    }

    private static void create() throws Exception {
        System.out.println("=== Create a knowledge base ===");
        String jsonBody = """
            {
                "name": "My Knowledge Base",
                "description": "Description of my knowledge base."
            }
        """;

        HttpClient client = HttpClient.newHttpClient();

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

        // Synchronous call
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("Response data: " + responseBody);
    }
}

import requests

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

# API name: Create a knowledge base
# Environment requirement: Python 3.10 or later

# Create
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": "My Knowledge Base",
        "description": "Description of my knowledge base."
    }

    response = requests.post(URL, json=payload, headers=headers)
    # Print the raw response content line by line
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # Check the response status and raise an exception if an error occurs
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # Create a knowledge base
        response = create(api_key)
    except requests.HTTPError as e:
        print(f"Request error: {e}")

package main

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

// API name: Create a knowledge base
// Environment requirement: Go 1.20 or later

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

// Create a knowledge base
func create(apiKey string) (*http.Response, error) {
    payload := map[string]interface{}{
        "name":        "My Knowledge Base",
        "description": "Description of my knowledge base.",
    }

    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
    }

    // Print the raw response content line by line
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("Request error, status code: %d", resp.StatusCode)
    }

    return resp, nil
}

func main() {

    apiKey := "YOUR_API_KEY"
    // Create a knowledge base
    _, err := create(apiKey)
    if err != nil {
        fmt.Printf("Request error: %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": "The ID of the knowledge base",
            "name": "The name of the knowledge base",
            "description": "The description of the knowledge base"
        }'

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

/**
 * API name: Update a knowledge base
 * Environment requirement: Java 17 or later
 */
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
        update();
    }

    private static void update() throws Exception {
        System.out.println("=== Update a knowledge base ===");
        String jsonBody = """
            {
             "knowledgeBaseId": "{your_knowledge_base_id}",
             "name": "My Updated Knowledge Base",
             "description": "Updated description."
            }
        """;

        HttpClient client = HttpClient.newHttpClient();

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

        // Synchronous call
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("Response data: " + responseBody);
    }
}

import requests

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

# API name: Update a knowledge base
# Environment requirement: Python 3.10 or later

# Update
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_knowledge_base_id}",
        "name": "My Knowledge Base 3",
        "description": "Description for knowledge base 3."
    }

    response = requests.post(URL, json=payload, headers=headers)
    # Print the raw response content line by line
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # Check the response status and raise an exception if an error occurs
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # Update a knowledge base
        response = update(api_key)
    except requests.HTTPError as e:
        print(f"Request error: {e}")

package main

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

// API name: Update a knowledge base
// Environment requirement: Go 1.20 or later

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

// Update a knowledge base
func update(apiKey string) (*http.Response, error) {
    payload := map[string]interface{}{
        "knowledgeBaseId": "{your_knowledge_base_id}",
        "name":            "My Updated Knowledge Base",
        "description":     "Updated 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
    }

    // Print the raw response content line by line
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("Request error, status code: %d", resp.StatusCode)
    }

    return resp, nil
}

func main() {
    apiKey := "YOUR_API_KEY"
    // Update a knowledge base
    _, err := update(apiKey)
    if err != nil {
        fmt.Printf("Request error: %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 name: Query knowledge bases
 * Environment requirement: Java 17 or later
 */
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 {
        // Query
        search();
    }

    private static void search() throws Exception {
        System.out.println("=== Query knowledge bases ===");
        String jsonBody = """
            {
                "pageNum": 1,
                "pageSize": 10
            }
        """;

        HttpClient client = HttpClient.newHttpClient();

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

        // Synchronous call
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("Response data: " + responseBody);
    }
}

import requests

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

# API name: Query knowledge bases
# Environment requirement: Python 3.10 or later

# Query
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)
    # Print the raw response content line by line
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # Check the response status and raise an exception if an error occurs
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # Query knowledge bases
        response = search(api_key)
    except requests.HTTPError as e:
        print(f"Request error: {e}")

package main

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

// API name: Query knowledge bases
// Environment requirement: Go 1.20 or later

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



// Query knowledge bases
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
    }

    // Print the raw response content line by line
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("Request error, status code: %d", resp.StatusCode)
    }

    return resp, nil
}

func main() {

    apiKey := "YOUR_API_KEY"
    // Query knowledge bases
    _, err := search(apiKey)
    if err != nil {
        fmt.Printf("Request error: %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": "{your_knowledge_base_id}"
        }'

/**
 * API name: Delete a knowledge base
 * Environment requirement: Java 17 or later
 */
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
       delete();
    }
    private static void delete() throws Exception {
        System.out.println("=== Delete a knowledge base ===");
        String jsonBody = """
            {
                "knowledgeBaseId": "{your_knowledge_base_id}"
            }
        """;

        HttpClient client = HttpClient.newHttpClient();

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

        // Synchronous call
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("Response data: " + responseBody);
    }
}

import requests

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

# API name: Delete a knowledge base
# Environment requirement: Python 3.10 or later

# Delete
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_knowledge_base_id}"
    }

    response = requests.post(URL, json=payload, headers=headers)
    # Print the raw response content line by line
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # Check the response status and raise an exception if an error occurs
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # Delete a knowledge base
        response = delete(api_key)
    except requests.HTTPError as e:
        print(f"Request error: {e}")

package main

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

// API name: Delete a knowledge base
// Environment requirement: Go 1.20 or later

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

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

    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
    }

    // Print the raw response content line by line
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("Request error, status code: %d", resp.StatusCode)
    }

    return resp, nil
}

func main() {

    apiKey := "YOUR_API_KEY"
    
    // Delete a knowledge base
    _, err := delete(apiKey)
    if err != nil {
        fmt.Printf("Request error: %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": "{your_knowledge_base_id}",
            "type": "text",
            "fileInfos": [
                {
                    "filename": "example.txt",
                    "fileUrl": "https://example.com/public_file.txt"				
                }
            ]
        }'

/**
 * API name: Upload a knowledge base file
 * Environment requirement: Java 17 or later
 */
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
       upload();
    }

    private static void upload() throws Exception {
        System.out.println("=== Upload a knowledge base file ===");
        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,
                        // Fixed servicename
                        "x-fag-servicename", "aca-kb-detail-upload",
                        "x-fag-appcode", "aca",
                        "Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        // Synchronous call
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("Response data: " + responseBody);
    }
}

import requests

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

# API name: Upload a knowledge base file
# Environment requirement: Python 3.10 or later

# Upload
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": "{your_knowledge_base_id}",
        "type": "text",
        "fileInfos": [
            {
                "fileUrl": "https://lang.alicdn.com/xingchen/guanyu.txt",
                "filename": "guanyu3.txt"
            }
        ]
    }

    response = requests.post(URL, json=payload, headers=headers)
    # Print the raw response content line by line
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # Check the response status and raise an exception if an error occurs
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # Upload a knowledge base file
        response = upload(api_key)
    except requests.HTTPError as e:
        print(f"Request error: {e}")

package main

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

// API name: Upload a knowledge base file
// Environment requirement: Go 1.20 or later

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

// Upload
func upload(apiKey string) (*http.Response, error) {
	payload := map[string]interface{}{
		"knowledgeBaseId": "{your_knowledge_base_id}",
		"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
	}

	// Print the raw response content line by line
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("Request error, status code: %d", resp.StatusCode)
	}

	return resp, nil
}

func main() {

	apiKey := "YOUR_API_KEY"
	// Upload
	_, err := upload(apiKey)
	if err != nil {
		fmt.Printf("Request error: %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": "{your_knowledge_base_id}",
            "name": "current_file.txt",
            "newName": "new_file.txt"
        }'

/**
 * API name: Update a knowledge base file
 * Environment requirement: Java 17 or later
 */
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
       update();

    }

    private static void update() throws Exception {
        System.out.println("=== Update a knowledge base file name ===");
        // Set the name field to the preceding filename.
        String jsonBody = """
       {
           "knowledgeBaseId": "{your_knowledge_base_id}",
           "name": "guanyu.txt",
           "newName": "newName.txt"
       }
        """;

        HttpClient client = HttpClient.newHttpClient();

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

        // Synchronous call
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("Response data: " + responseBody);
    }
}

import requests

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

# API name: Update a knowledge base file
# Environment requirement: Python 3.10 or later

# Update
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}"
    }
    # Set name to the preceding filename.
    payload = {
        "knowledgeBaseId": "{your_knowledge_base_id}",
        "name": "guanyu.txt",
        "newName": "newName.txt"
    }

    response = requests.post(URL, json=payload, headers=headers)
    # Print the raw response content line by line
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # Check the response status and raise an exception if an error occurs
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # Update a knowledge base file
        response = update(api_key)
    except requests.HTTPError as e:
        print(f"Request error: {e}")

package main

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

// API name: Update a knowledge base file
// Environment requirement: Go 1.20 or later

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

// Update a knowledge base file
func update(apiKey string) (*http.Response, error) {
	// Set name to the preceding filename.
	payload := map[string]interface{}{
		"knowledgeBaseId": "{your_knowledge_base_id}",
		"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
	}

	// Print the raw response content line by line
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("Request error, status code: %d", resp.StatusCode)
	}

	return resp, nil
}

func main() {

	apiKey := "YOUR_API_KEY"
	
	// Update a knowledge base file
	_, err := update(apiKey)
	if err != nil {
		fmt.Printf("Request error: %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": "{your_knowledge_base_id}",
            "pageNum": 1,
            "pageSize": 10
        }'

/**
 * API name: Query knowledge base files
 * Environment requirement: Java 17 or later
 */
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 {
        // Query
        search();
    }

    private static void search() throws Exception {
        System.out.println("=== Query knowledge base files ===");
        String jsonBody = """
        {
            "knowledgeBaseId": "{your_knowledge_base_id}",
            "pageNum": 1,
            "pageSize": 10
        }
        """;

        HttpClient client = HttpClient.newHttpClient();

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

        // Synchronous call
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("Response data: " + responseBody);
    }
}

import requests

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

# API name: Query knowledge base files
# Environment requirement: Python 3.10 or later

# Query
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": "{your_knowledge_base_id}",
        "pageNum": 1,
        "pageSize": 10
    }

    response = requests.post(URL, json=payload, headers=headers)
    # Print the raw response content line by line
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # Check the response status and raise an exception if an error occurs
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # Query knowledge base files
        response = search(api_key)
    except requests.HTTPError as e:
        print(f"Request error: {e}")

package main

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

// API name: Query knowledge base files
// Environment requirement: Go 1.20 or later

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

// Query knowledge base files
func search(apiKey string) (*http.Response, error) {
	payload := map[string]interface{}{
		"knowledgeBaseId": "{your_knowledge_base_id}",
		"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
	}

	// Print the raw response content line by line
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("Request error, status code: %d", resp.StatusCode)
	}

	return resp, nil
}

func main() {

	apiKey := "YOUR_API_KEY"
	//Query knowledge base files
	_, err := search(apiKey)
	if err != nil {
		fmt.Printf("Request error: %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": "{your_knowledge_base_id}",
            "name": "example_detail_name"
        }'

/**
 * API name: Delete a knowledge base file
 * Environment requirement: Java 17 or later
 */
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
       delete();
    }

    private static void delete() throws Exception {
        System.out.println("=== Delete a knowledge base file ===");
        String jsonBody = """
            {
                "knowledgeBaseId": "{your_knowledge_base_id}",
                "name": "newName.txt"
            }
        """;

        HttpClient client = HttpClient.newHttpClient();

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

        // Synchronous call
        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        String responseBody = response.body();
        System.out.println("Response data: " + responseBody);
    }
}

import requests

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

# API name: Delete a knowledge base file
# Environment requirement: Python 3.10 or later

# Delete
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": "{your_knowledge_base_id}",
        "name": "guanyu.txt"
    }

    response = requests.post(URL, json=payload, headers=headers)
    # Print the raw response content line by line
    for line in response.iter_lines():
        if line:
            print(line.decode('utf-8'))
    # Check the response status and raise an exception if an error occurs
    response.raise_for_status()
    return response

if __name__ == "__main__":
    api_key = "YOUR_API_KEY"
    model_name = "xingchen-plus-latest"
    try:
        # Delete
        response = delete(api_key)
    except requests.HTTPError as e:
        print(f"Request error: {e}")

package main

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

// API name: Delete a knowledge base file
// Environment requirement: Go 1.20 or later

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

// Delete
func delete(apiKey string) (*http.Response, error) {
	payload := map[string]interface{}{
		"knowledgeBaseId": "{your_knowledge_base_id}",
		"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
	}

	// Print the raw response content line by line
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("Request error, status code: %d", resp.StatusCode)
	}

	return resp, nil
}

func main() {

	apiKey := "YOUR_API_KEY"

	// Delete
	_, err := delete(apiKey)
	if err != nil {
		fmt.Printf("Request error: %v\n", err)
	}
}