Guides

AI Chat

Suggest Edits
AI Chat Knowledgebases API

🤖 AI Chat Knowledgebases API

Manage your AI chat knowledgebases, files, and sessions with the following API endpoints.

📚 List & Create Knowledgebases

GET, POST → /ai_chat/knowledgebases

GET: Retrieves all knowledgebases associated with your account.

POST: Creates a new knowledgebase.


import requests
import json

# API Base URL
API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases"

# Replace with your actual API key
API_KEY = "your_api_key"

# Set up headers
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
}

# GET Request - Retrieve all knowledgebases
response = requests.get(API_BASE_URL, headers=headers)

if response.status_code == 200:
    print("Knowledgebases retrieved successfully:")
    print(response.json())
else:
    print("Failed to retrieve knowledgebases:", response.status_code)
    print(response.text)

# POST Request - Create a new knowledgebase
payload = {"name": "my_knowledgebase"}

response = requests.post(API_BASE_URL, headers=headers, json=payload)

if response.status_code == 200:
    print("Knowledgebase created successfully:")
    print(response.json())
else:
    print("Failed to create knowledgebase:", response.status_code)
    print(response.text)


const axios = require('axios');

const API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases";
const API_KEY = "your_api_key";

const headers = {
    "Authorization": `Bearer ${API_KEY}`,
    "Content-Type": "application/json",
    "Accept": "application/json"
};

// GET Request - Retrieve all knowledgebases
axios.get(API_BASE_URL, { headers })
    .then(response => {
        console.log("Knowledgebases retrieved successfully:");
        console.log(response.data);
    })
    .catch(error => {
        console.error("Failed to retrieve knowledgebases:", error.response?.status, error.response?.data);
    });

// POST Request - Create a new knowledgebase
const payload = { name: "my_knowledgebase" };

axios.post(API_BASE_URL, payload, { headers })
    .then(response => {
        console.log("Knowledgebase created successfully:");
        console.log(response.data);
    })
    .catch(error => {
        console.error("Failed to create knowledgebase:", error.response?.status, error.response?.data);
    });




import okhttp3.*;
import org.json.JSONObject;

public class KnowledgebaseAPI {
    private static final String API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases";
    private static final String API_KEY = "your_api_key";

    public static void main(String[] args) throws Exception {
        OkHttpClient client = new OkHttpClient();

        // GET Request - Retrieve all knowledgebases
        Request getRequest = new Request.Builder()
                .url(API_BASE_URL)
                .addHeader("Authorization", "Bearer " + API_KEY)
                .addHeader("Accept", "application/json")
                .build();

        Response getResponse = client.newCall(getRequest).execute();
        if (getResponse.isSuccessful()) {
            System.out.println("Knowledgebases retrieved successfully:");
            System.out.println(getResponse.body().string());
        } else {
            System.out.println("Failed to retrieve knowledgebases: " + getResponse.code());
        }

        // POST Request - Create a new knowledgebase
        JSONObject json = new JSONObject();
        json.put("name", "my_knowledgebase");

        RequestBody body = RequestBody.create(json.toString(), MediaType.parse("application/json"));

        Request postRequest = new Request.Builder()
                .url(API_BASE_URL)
                .post(body)
                .addHeader("Authorization", "Bearer " + API_KEY)
                .addHeader("Content-Type", "application/json")
                .build();

        Response postResponse = client.newCall(postRequest).execute();
        if (postResponse.isSuccessful()) {
            System.out.println("Knowledgebase created successfully:");
            System.out.println(postResponse.body().string());
        } else {
            System.out.println("Failed to create knowledgebase: " + postResponse.code());
        }
    }
}




using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program {
    private static readonly string API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases";
    private static readonly string API_KEY = "your_api_key";

    static async Task Main() {
        HttpClient client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", $"Bearer {API_KEY}");
        client.DefaultRequestHeaders.Add("Accept", "application/json");

        // GET Request - Retrieve all knowledgebases
        HttpResponseMessage getResponse = await client.GetAsync(API_BASE_URL);
        if (getResponse.IsSuccessStatusCode) {
            Console.WriteLine("Knowledgebases retrieved successfully:");
            Console.WriteLine(await getResponse.Content.ReadAsStringAsync());
        } else {
            Console.WriteLine($"Failed to retrieve knowledgebases: {getResponse.StatusCode}");
        }

        // POST Request - Create a new knowledgebase
        var payload = new { name = "my_knowledgebase" };
        var jsonContent = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");

        HttpResponseMessage postResponse = await client.PostAsync(API_BASE_URL, jsonContent);
        if (postResponse.IsSuccessStatusCode) {
            Console.WriteLine("Knowledgebase created successfully:");
            Console.WriteLine(await postResponse.Content.ReadAsStringAsync());
        } else {
            Console.WriteLine($"Failed to create knowledgebase: {postResponse.StatusCode}");
        }
    }
}



package main

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

const API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases"
const API_KEY = "your_api_key"

func main() {
	client := &http.Client{}

	// GET Request - Retrieve all knowledgebases
	req, _ := http.NewRequest("GET", API_BASE_URL, nil)
	req.Header.Set("Authorization", "Bearer "+API_KEY)
	req.Header.Set("Accept", "application/json")

	resp, _ := client.Do(req)
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println("Knowledgebases retrieved successfully:", string(body))

	// POST Request - Create a new knowledgebase
	payload := map[string]string{"name": "my_knowledgebase"}
	jsonData, _ := json.Marshal(payload)

	req, _ = http.NewRequest("POST", API_BASE_URL, bytes.NewBuffer(jsonData))
	req.Header.Set("Authorization", "Bearer "+API_KEY)
	req.Header.Set("Content-Type", "application/json")

	resp, _ = client.Do(req)
	body, _ = ioutil.ReadAll(resp.Body)
	fmt.Println("Knowledgebase created successfully:", string(body))
}




require 'net/http'
require 'json'

API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases"
API_KEY = "your_api_key"

headers = {
  "Authorization" => "Bearer #{API_KEY}",
  "Content-Type" => "application/json",
  "Accept" => "application/json"
}

# GET Request - Retrieve all knowledgebases
uri = URI(API_BASE_URL)
response = Net::HTTP.get_response(uri, headers)
puts "Knowledgebases retrieved successfully:" if response.code.to_i == 200
puts response.body

# POST Request - Create a new knowledgebase
uri = URI(API_BASE_URL)
payload = { name: "my_knowledgebase" }.to_json
response = Net::HTTP.post(uri, payload, headers)

puts "Knowledgebase created successfully:" if response.code.to_i == 200
puts response.body




<?php
$API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases";
$API_KEY = "your_api_key";

$headers = [
    "Authorization: Bearer $API_KEY",
    "Content-Type: application/json",
    "Accept: application/json"
];

// GET Request - Retrieve all knowledgebases
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $API_BASE_URL);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);
echo "Knowledgebases retrieved successfully:\n$response\n";

// POST Request - Create a new knowledgebase
$ch = curl_init();
$data = json_encode(["name" => "my_knowledgebase"]);
curl_setopt($ch, CURLOPT_URL, $API_BASE_URL);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
echo "Knowledgebase created successfully:\n$response\n";
?>



import okhttp3.*
import org.json.JSONObject

fun main() {
    val API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases"
    val API_KEY = "your_api_key"
    val client = OkHttpClient()

    val request = Request.Builder()
        .url(API_BASE_URL)
        .addHeader("Authorization", "Bearer $API_KEY")
        .build()

    val response = client.newCall(request).execute()
    println("Knowledgebases retrieved successfully: ${response.body()?.string()}")

    val json = JSONObject().put("name", "my_knowledgebase")
    val body = RequestBody.create(MediaType.parse("application/json"), json.toString())

    val postRequest = Request.Builder()
        .url(API_BASE_URL)
        .post(body)
        .addHeader("Authorization", "Bearer $API_KEY")
        .build()

    val postResponse = client.newCall(postRequest).execute()
    println("Knowledgebase created successfully: ${postResponse.body()?.string()}")
}




import Foundation

let API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases"
let API_KEY = "your_api_key"

// Headers
var headers = [
    "Authorization": "Bearer \(API_KEY)",
    "Content-Type": "application/json",
    "Accept": "application/json"
]

// GET Request - Retrieve all knowledgebases
func getKnowledgebases() {
    guard let url = URL(string: API_BASE_URL) else { return }

    var request = URLRequest(url: url)
    request.httpMethod = "GET"
    request.allHTTPHeaderFields = headers

    let task = URLSession.shared.dataTask(with: request) { data, response, error in
        if let data = data {
            print("Knowledgebases retrieved successfully:")
            print(String(data: data, encoding: .utf8) ?? "No data")
        } else {
            print("Failed to retrieve knowledgebases:", error?.localizedDescription ?? "Unknown error")
        }
    }
    task.resume()
}

// POST Request - Create a new knowledgebase
func createKnowledgebase() {
    guard let url = URL(string: API_BASE_URL) else { return }

    let payload: [String: Any] = ["name": "my_knowledgebase"]
    let jsonData = try? JSONSerialization.data(withJSONObject: payload)

    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.allHTTPHeaderFields = headers
    request.httpBody = jsonData

    let task = URLSession.shared.dataTask(with: request) { data, response, error in
        if let data = data {
            print("Knowledgebase created successfully:")
            print(String(data: data, encoding: .utf8) ?? "No data")
        } else {
            print("Failed to create knowledgebase:", error?.localizedDescription ?? "Unknown error")
        }
    }
    task.resume()
}

// Execute functions
getKnowledgebases()
createKnowledgebase()




import 'dart:convert';
import 'dart:io';

void main() async {
  const API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases";
  const API_KEY = "your_api_key";

  final headers = {
    HttpHeaders.authorizationHeader: "Bearer $API_KEY",
    HttpHeaders.contentTypeHeader: "application/json",
    HttpHeaders.acceptHeader: "application/json"
  };

  // GET Request - Retrieve all knowledgebases
  var getRequest = await HttpClient().getUrl(Uri.parse(API_BASE_URL));
  headers.forEach((key, value) => getRequest.headers.set(key, value));

  var getResponse = await getRequest.close();
  if (getResponse.statusCode == 200) {
    var jsonResponse = await getResponse.transform(utf8.decoder).join();
    print("Knowledgebases retrieved successfully:");
    print(jsonResponse);
  } else {
    print("Failed to retrieve knowledgebases: ${getResponse.statusCode}");
  }

  // POST Request - Create a new knowledgebase
  var postRequest = await HttpClient().postUrl(Uri.parse(API_BASE_URL));
  headers.forEach((key, value) => postRequest.headers.set(key, value));

  var payload = jsonEncode({"name": "my_knowledgebase"});
  postRequest.write(payload);

  var postResponse = await postRequest.close();
  if (postResponse.statusCode == 200) {
    var jsonResponse = await postResponse.transform(utf8.decoder).join();
    print("Knowledgebase created successfully:");
    print(jsonResponse);
  } else {
    print("Failed to create knowledgebase: ${postResponse.statusCode}");
  }
}

📌 Retrieve, Update & Delete a Knowledgebase

GET, POST, DELETE → /ai_chat/knowledgebases/:knowledge_base_id

GET: Retrieves details for a specific knowledgebase.

POST: Updates the knowledgebase name.

DELETE: Deletes the specified knowledgebase.


import requests
import json

# API Base URL
API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases"

# Replace with your actual API key
API_KEY = "your_api_key"

# Replace with an actual knowledge_base_id
KNOWLEDGE_BASE_ID = "your_knowledge_base_id"

# Set up headers
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
}

# GET Request - Retrieve a specific knowledgebase
url = f"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}"
response = requests.get(url, headers=headers)

if response.status_code == 200:
    print("Knowledgebase retrieved successfully:")
    print(response.json())
else:
    print("Failed to retrieve knowledgebase:", response.status_code)
    print(response.text)

# POST Request - Update a knowledgebase
url = f"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}"
payload = {
    "name": "new name"
}

response = requests.post(url, headers=headers, json=payload)

if response.status_code == 200:
    print("Knowledgebase updated successfully:")
    print(response.json())
else:
    print("Failed to update knowledgebase:", response.status_code)
    print(response.text)

# DELETE Request - Delete a knowledgebase
url = f"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}"

response = requests.delete(url, headers=headers)

if response.status_code == 200:
    print("Knowledgebase deleted successfully")
else:
    print("Failed to delete knowledgebase:", response.status_code)
    print(response.text)

📂 Manage Files in a Knowledgebase

POST, DELETE → /ai_chat/knowledgebases/:knowledge_base_id/files

POST: Adds a file to the specified knowledgebase.

DELETE: Removes a file from the knowledgebase.


import requests
import json

# API Base URL
API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases"

# Replace with your actual API key
API_KEY = "your_api_key"

# Replace with actual knowledge_base_id and order_id
KNOWLEDGE_BASE_ID = "your_knowledgebase_id"
ORDER_ID = "your_order_id"

# Set up headers
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
}

# POST Request - Add a file to the knowledgebase
url = f"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}/files"
payload = {"transkriptor_order_id": ORDER_ID}

response = requests.post(url, headers=headers, json=payload)

if response.status_code == 200:
    print("File added to knowledgebase successfully:")
    print(response.json())
else:
    print("Failed to add file to knowledgebase:", response.status_code)
    print(response.text)

knowledbase_file_id = response.json()["file"]["knowledge_base_file_id"]

# DELETE Request - Remove a file from the knowledgebase
url = f"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}/files/{knowledbase_file_id}"

response = requests.delete(url, headers=headers)

if response.status_code == 200:
    print("File deleted from knowledgebase successfully")
else:
    print("Failed to delete file from knowledgebase:", response.status_code)
    print(response.text)


const axios = require("axios");

const API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases";
const API_KEY = "your_api_key";
const KNOWLEDGE_BASE_ID = "your_knowledgebase_id";
const ORDER_ID = "your_order_id";

const headers = {
  "Authorization": `Bearer ${API_KEY}`,
  "Content-Type": "application/json",
  "Accept": "application/json"
};

// POST Request - Add a file to the knowledgebase
const addFileToKnowledgebase = async () => {
  try {
    const response = await axios.post(`${API_BASE_URL}/${KNOWLEDGE_BASE_ID}/files`, 
      { transkriptor_order_id: ORDER_ID }, 
      { headers }
    );
    console.log("File added to knowledgebase successfully:");
    console.log(response.data);

    const knowledgeBaseFileId = response.data.file.knowledge_base_file_id;

    // DELETE Request - Remove a file from the knowledgebase
    const deleteResponse = await axios.delete(`${API_BASE_URL}/${KNOWLEDGE_BASE_ID}/files/${knowledgeBaseFileId}`, 
      { headers }
    );

    console.log("File deleted from knowledgebase successfully");

  } catch (error) {
    console.error("Error:", error.response ? error.response.data : error.message);
  }
};

addFileToKnowledgebase();




import okhttp3.*;
import org.json.JSONObject;

public class KnowledgebaseFileManager {
    private static final String API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases";
    private static final String API_KEY = "your_api_key";
    private static final String KNOWLEDGE_BASE_ID = "your_knowledgebase_id";
    private static final String ORDER_ID = "your_order_id";

    public static void main(String[] args) throws Exception {
        OkHttpClient client = new OkHttpClient();

        // POST Request - Add a file to the knowledgebase
        String postUrl = API_BASE_URL + "/" + KNOWLEDGE_BASE_ID + "/files";
        JSONObject postBody = new JSONObject();
        postBody.put("transkriptor_order_id", ORDER_ID);

        Request postRequest = new Request.Builder()
                .url(postUrl)
                .post(RequestBody.create(postBody.toString(), MediaType.parse("application/json")))
                .addHeader("Authorization", "Bearer " + API_KEY)
                .addHeader("Content-Type", "application/json")
                .build();

        Response postResponse = client.newCall(postRequest).execute();
        if (postResponse.isSuccessful()) {
            System.out.println("File added to knowledgebase successfully.");
            JSONObject responseBody = new JSONObject(postResponse.body().string());
            String knowledgeBaseFileId = responseBody.getJSONObject("file").getString("knowledge_base_file_id");

            // DELETE Request - Remove a file from the knowledgebase
            String deleteUrl = API_BASE_URL + "/" + KNOWLEDGE_BASE_ID + "/files/" + knowledgeBaseFileId;
            Request deleteRequest = new Request.Builder()
                    .url(deleteUrl)
                    .delete()
                    .addHeader("Authorization", "Bearer " + API_KEY)
                    .build();

            Response deleteResponse = client.newCall(deleteRequest).execute();
            if (deleteResponse.isSuccessful()) {
                System.out.println("File deleted from knowledgebase successfully.");
            } else {
                System.out.println("Failed to delete file: " + deleteResponse.code());
            }

        } else {
            System.out.println("Failed to add file: " + postResponse.code());
        }
    }
}




using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    private static readonly string API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases";
    private static readonly string API_KEY = "your_api_key";
    private static readonly string KNOWLEDGE_BASE_ID = "your_knowledgebase_id";
    private static readonly string ORDER_ID = "your_order_id";

    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", $"Bearer {API_KEY}");

        // POST Request - Add file
        var payload = JsonSerializer.Serialize(new { transkriptor_order_id = ORDER_ID });
        var content = new StringContent(payload, Encoding.UTF8, "application/json");

        var postResponse = await client.PostAsync($"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}/files", content);
        if (postResponse.IsSuccessStatusCode)
        {
            var jsonResponse = await postResponse.Content.ReadAsStringAsync();
            Console.WriteLine("File added successfully: " + jsonResponse);

            var jsonDoc = JsonDocument.Parse(jsonResponse);
            string knowledgeBaseFileId = jsonDoc.RootElement.GetProperty("file").GetProperty("knowledge_base_file_id").GetString();

            // DELETE Request - Remove file
            var deleteResponse = await client.DeleteAsync($"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}/files/{knowledgeBaseFileId}");
            if (deleteResponse.IsSuccessStatusCode)
            {
                Console.WriteLine("File deleted successfully.");
            }
            else
            {
                Console.WriteLine("Failed to delete file: " + deleteResponse.StatusCode);
            }
        }
        else
        {
            Console.WriteLine("Failed to add file: " + postResponse.StatusCode);
        }
    }




package main

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

const (
	API_BASE_URL       = "https://api.tor.app/developer/ai_chat/knowledgebases"
	API_KEY            = "your_api_key"
	KNOWLEDGE_BASE_ID  = "your_knowledgebase_id"
	ORDER_ID           = "your_order_id"
)

func main() {
	client := &http.Client{}

	// POST Request - Add file to knowledgebase
	url := fmt.Sprintf("%s/%s/files", API_BASE_URL, KNOWLEDGE_BASE_ID)
	payload, _ := json.Marshal(map[string]string{"transkriptor_order_id": ORDER_ID})

	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
	req.Header.Set("Authorization", "Bearer "+API_KEY)
	req.Header.Set("Content-Type", "application/json")

	resp, _ := client.Do(req)
	body, _ := ioutil.ReadAll(resp.Body)
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusOK {
		fmt.Println("File added to knowledgebase successfully:")
		fmt.Println(string(body))

		// Extract file ID
		var result map[string]map[string]string
		json.Unmarshal(body, &result)
		fileID := result["file"]["knowledge_base_file_id"]

		// DELETE Request - Remove file from knowledgebase
		deleteURL := fmt.Sprintf("%s/%s/files/%s", API_BASE_URL, KNOWLEDGE_BASE_ID, fileID)
		deleteReq, _ := http.NewRequest("DELETE", deleteURL, nil)
		deleteReq.Header.Set("Authorization", "Bearer "+API_KEY)

		deleteResp, _ := client.Do(deleteReq)
		defer deleteResp.Body.Close()

		if deleteResp.StatusCode == http.StatusOK {
			fmt.Println("File deleted from knowledgebase successfully.")
		} else {
			fmt.Println("Failed to delete file:", deleteResp.StatusCode)
		}
	} else {
		fmt.Println("Failed to add file:", resp.StatusCode)
	}
}



require 'net/http'
require 'json'
require 'uri'

API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases"
API_KEY = "your_api_key"
KNOWLEDGE_BASE_ID = "your_knowledgebase_id"
ORDER_ID = "your_order_id"

headers = {
  "Authorization" => "Bearer #{API_KEY}",
  "Content-Type" => "application/json",
  "Accept" => "application/json"
}

# POST Request - Add file
url = URI("#{API_BASE_URL}/#{KNOWLEDGE_BASE_ID}/files")
body = { "transkriptor_order_id" => ORDER_ID }.to_json
response = Net::HTTP.post(url, body, headers)

if response.code.to_i == 200
  puts "File added to knowledgebase successfully"
  response_data = JSON.parse(response.body)
  file_id = response_data["file"]["knowledge_base_file_id"]

  # DELETE Request - Remove file
  delete_url = URI("#{API_BASE_URL}/#{KNOWLEDGE_BASE_ID}/files/#{file_id}")
  delete_response = Net::HTTP.delete(delete_url, headers)

  puts delete_response.code.to_i == 200 ? "File deleted successfully" : "Failed to delete file"
else
  puts "Failed to add file"
end




<?php
$apiBaseUrl = "https://api.tor.app/developer/ai_chat/knowledgebases";
$apiKey = "your_api_key";
$knowledgeBaseId = "your_knowledgebase_id";
$orderId = "your_order_id";

$headers = [
    "Authorization: Bearer $apiKey",
    "Content-Type: application/json",
    "Accept: application/json"
];

// POST Request - Add file to knowledgebase
$postUrl = "$apiBaseUrl/$knowledgeBaseId/files";
$postData = json_encode(["transkriptor_order_id" => $orderId]);

$ch = curl_init($postUrl);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpCode == 200) {
    echo "File added to knowledgebase successfully.\n";
    $responseData = json_decode($response, true);
    $fileId = $responseData["file"]["knowledge_base_file_id"];

    // DELETE Request - Remove file from knowledgebase
    $deleteUrl = "$apiBaseUrl/$knowledgeBaseId/files/$fileId";
    $ch = curl_init($deleteUrl);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

    $deleteResponse = curl_exec($ch);
    $deleteHttpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($deleteHttpCode == 200) {
        echo "File deleted from knowledgebase successfully.\n";
    } else {
        echo "Failed to delete file. HTTP Code: $deleteHttpCode\n";
    }
} else {
    echo "Failed to add file. HTTP Code: $httpCode\n";
}
?>



import okhttp3.*
import org.json.JSONObject

fun main() {
    val apiBaseUrl = "https://api.tor.app/developer/ai_chat/knowledgebases"
    val apiKey = "your_api_key"
    val knowledgeBaseId = "your_knowledgebase_id"
    val orderId = "your_order_id"

    val client = OkHttpClient()
    val headers = Headers.Builder()
        .add("Authorization", "Bearer $apiKey")
        .add("Content-Type", "application/json")
        .build()

    // POST Request - Add file to knowledgebase
    val postUrl = "$apiBaseUrl/$knowledgeBaseId/files"
    val postBody = JSONObject().put("transkriptor_order_id", orderId).toString()
    val postRequest = Request.Builder()
        .url(postUrl)
        .post(RequestBody.create(MediaType.parse("application/json"), postBody))
        .headers(headers)
        .build()

    client.newCall(postRequest).execute().use { response ->
        if (response.isSuccessful) {
            println("File added to knowledgebase successfully.")
            val jsonResponse = JSONObject(response.body()!!.string())
            val fileId = jsonResponse.getJSONObject("file").getString("knowledge_base_file_id")

            // DELETE Request - Remove file from knowledgebase
            val deleteUrl = "$apiBaseUrl/$knowledgeBaseId/files/$fileId"
            val deleteRequest = Request.Builder()
                .url(deleteUrl)
                .delete()
                .headers(headers)
                .build()

            client.newCall(deleteRequest).execute().use { deleteResponse ->
                if (deleteResponse.isSuccessful) {
                    println("File deleted from knowledgebase successfully.")
                } else {
                    println("Failed to delete file. HTTP Code: ${deleteResponse.code()}")
                }
            }
        } else {
            println("Failed to add file. HTTP Code: ${response.code()}")
        }
    }
}




import Foundation

let apiBaseUrl = "https://api.tor.app/developer/ai_chat/knowledgebases"
let apiKey = "your_api_key"
let knowledgeBaseId = "your_knowledgebase_id"
let orderId = "your_order_id"

var request = URLRequest(url: URL(string: "\(apiBaseUrl)/\(knowledgeBaseId)/files")!)
request.httpMethod = "POST"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let body: [String: String] = ["transkriptor_order_id": orderId]
request.httpBody = try? JSONSerialization.data(withJSONObject: body, options: [])

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    guard let data = data, let response = response as? HTTPURLResponse else {
        print("Request failed.")
        return
    }
    
    if response.statusCode == 200 {
        print("File added to knowledgebase successfully.")
        
        if let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any],
           let fileId = (json["file"] as? [String: Any])?["knowledge_base_file_id"] as? String {

            // DELETE Request - Remove file from knowledgebase
            var deleteRequest = URLRequest(url: URL(string: "\(apiBaseUrl)/\(knowledgeBaseId)/files/\(fileId)")!)
            deleteRequest.httpMethod = "DELETE"
            deleteRequest.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")

            let deleteTask = URLSession.shared.dataTask(with: deleteRequest) { _, deleteResponse, _ in
                if let deleteResponse = deleteResponse as? HTTPURLResponse, deleteResponse.statusCode == 200 {
                    print("File deleted from knowledgebase successfully.")
                } else {
                    print(




import 'dart:convert';
import 'dart:io';

void main() async {
  const String apiBaseUrl = "https://api.tor.app/developer/ai_chat/knowledgebases";
  const String apiKey = "your_api_key";
  const String knowledgeBaseId = "your_knowledgebase_id";
  const String orderId = "your_order_id";

  HttpClient client = HttpClient();

  // POST Request - Add file to knowledgebase
  HttpClientRequest request = await client.postUrl(Uri.parse("$

💬 Chat Sessions

POST → /ai_chat/knowledgebases/:knowledge_base_id/sessions

POST: Creates a new chat session within the specified knowledgebase.

GET, POST → /ai_chat/knowledgebases/:knowledge_base_id/sessions/:session_id

GET: Retrieves details of a session.

POST: Sends a new message in the session.


import requests
import json

# API Base URL
API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases"

# Replace with your actual API key
API_KEY = "your_api_key"

# Replace with actual knowledge_base_id and session_id
KNOWLEDGE_BASE_ID = "your_knowledgebase_id"
ORDER_ID = "your_order_id"

# Set up headers
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
}

# POST Request - Create a new session
create_session_url = f"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}/sessions"
create_payload = {}

response = requests.post(create_session_url, headers=headers, json=create_payload)

SESSION_ID = None
if response.status_code == 200 or response.status_code == 201:
    session_data = response.json()
    print("Session created successfully:", session_data)
    SESSION_ID = session_data["session"]["session_id"]  # Retrieve the new session ID
else:
    print("Failed to create session:", response.status_code)
    print(response.text)

# GET Request - Retrieve session details
get_session_url = f"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}/sessions/{SESSION_ID}"
response = requests.get(get_session_url, headers=headers)

if response.status_code == 200:
    print("Session retrieved successfully:")
    print(response.json())
else:
    print("Failed to retrieve session:", response.status_code)
    print(response.text)

# POST Request - Send a message to the session
send_message_url = f"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}/sessions/{SESSION_ID}"
message_payload = {"query": "never gonna give you up"}

response = requests.post(send_message_url, headers=headers, json=message_payload)

if response.status_code == 200:
    print("Message sent successfully. AI Response:")
    print(response.json())
else:
    print("Failed to send message:", response.status_code)
    print(response.text)


const axios = require("axios");

const API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases";
const API_KEY = "your_api_key";
const KNOWLEDGE_BASE_ID = "your_knowledgebase_id";
let SESSION_ID = null;

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  "Content-Type": "application/json",
  Accept: "application/json",
};

// POST Request - Create a new session
axios
  .post(`${API_BASE_URL}/${KNOWLEDGE_BASE_ID}/sessions`, {}, { headers })
  .then((response) => {
    console.log("Session created successfully:", response.data);
    SESSION_ID = response.data.session.session_id;

    // GET Request - Retrieve session details
    return axios.get(`${API_BASE_URL}/${KNOWLEDGE_BASE_ID}/sessions/${SESSION_ID}`, { headers });
  })
  .then((response) => {
    console.log("Session retrieved successfully:", response.data);

    // POST Request - Send a message to the session
    return axios.post(
      `${API_BASE_URL}/${KNOWLEDGE_BASE_ID}/sessions/${SESSION_ID}`,
      { query: "never gonna give you up" },
      { headers }
    );
  })
  .then((response) => {
    console.log("Message sent successfully. AI Response:", response.data);
  })
  .catch((error) => {
    console.error("Error:", error.response ? error.response.data : error.message);
  });




import okhttp3.*;
import org.json.JSONObject;

import java.io.IOException;

public class KnowledgeBaseChat {
    private static final String API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases";
    private static final String API_KEY = "your_api_key";
    private static final String KNOWLEDGE_BASE_ID = "your_knowledgebase_id";
    private static String SESSION_ID = null;

    public static void main(String[] args) throws IOException {
        OkHttpClient client = new OkHttpClient();
        RequestBody emptyBody = RequestBody.create("", MediaType.parse("application/json"));

        Request createSessionRequest = new Request.Builder()
                .url(API_BASE_URL + "/" + KNOWLEDGE_BASE_ID + "/sessions")
                .post(emptyBody)
                .addHeader("Authorization", "Bearer " + API_KEY)
                .addHeader("Content-Type", "application/json")
                .build();

        Response createSessionResponse = client.newCall(createSessionRequest).execute();
        if (createSessionResponse.isSuccessful()) {
            JSONObject jsonResponse = new JSONObject(createSessionResponse.body().string());
            SESSION_ID = jsonResponse.getJSONObject("session").getString("session_id");
            System.out.println("Session created successfully: " + jsonResponse);

            Request getSessionRequest = new Request.Builder()
                    .url(API_BASE_URL + "/" + KNOWLEDGE_BASE_ID + "/sessions/" + SESSION_ID)
                    .get()
                    .addHeader("Authorization", "Bearer " + API_KEY)
                    .build();

            Response getSessionResponse = client.newCall(getSessionRequest).execute();
            System.out.println("Session retrieved successfully: " + getSessionResponse.body().string());

            JSONObject messagePayload = new JSONObject();
            messagePayload.put("query", "never gonna give you up");

            RequestBody messageBody = RequestBody.create(messagePayload.toString(), MediaType.parse("application/json"));
            Request sendMessageRequest = new Request.Builder()
                    .url(API_BASE_URL + "/" + KNOWLEDGE_BASE_ID + "/sessions/" + SESSION_ID)
                    .post(messageBody)
                    .addHeader("Authorization", "Bearer " + API_KEY)
                    .addHeader("Content-Type", "application/json")
                    .build();

            Response sendMessageResponse = client.newCall(sendMessageRequest).execute();
            System.out.println("Message sent successfully. AI Response: " + sendMessageResponse.body().string());
        } else {
            System.out.println("Failed to create session: " + createSessionResponse.code());
        }
    }
}




using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;

class Program
{
    private static readonly string API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases";
    private static readonly string API_KEY = "your_api_key";
    private static readonly string KNOWLEDGE_BASE_ID = "your_knowledgebase_id";
    private static string SESSION_ID = null;

    static async Task Main()
    {
        using HttpClient client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", $"Bearer {API_KEY}");

        // POST - Create session
        HttpResponseMessage createSessionResponse = await client.PostAsync($"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}/sessions", new StringContent("{}", Encoding.UTF8, "application/json"));
        if (createSessionResponse.IsSuccessStatusCode)
        {
            string jsonResponse = await createSessionResponse.Content.ReadAsStringAsync();
            SESSION_ID = JObject.Parse(jsonResponse)["session"]["session_id"].ToString();
            Console.WriteLine("Session created successfully: " + jsonResponse);

            // GET - Retrieve session
            HttpResponseMessage getSessionResponse = await client.GetAsync($"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}/sessions/{SESSION_ID}");
            Console.WriteLine("Session retrieved successfully: " + await getSessionResponse.Content.ReadAsStringAsync());

            // POST - Send message
            StringContent messageContent = new StringContent("{\"query\": \"never gonna give you up\"}", Encoding.UTF8, "application/json");
            HttpResponseMessage sendMessageResponse = await client.PostAsync($"{API_BASE_URL}/{KNOWLEDGE_BASE_ID}/sessions/{SESSION_ID}", messageContent);
            Console.WriteLine("Message sent successfully. AI Response: " + await sendMessageResponse.Content.ReadAsStringAsync());
        }
        else
        {
            Console.WriteLine("Failed to create session.");
        }
    }
}



package main

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

const (
	apiBaseUrl       = "https://api.tor.app/developer/ai_chat/knowledgebases"
	apiKey           = "your_api_key"
	knowledgeBaseId  = "your_knowledgebase_id"
)

func main() {
	client := &http.Client{}

	// Create Session
	createSessionUrl := fmt.Sprintf("%s/%s/sessions", apiBaseUrl, knowledgeBaseId)
	req, _ := http.NewRequest("POST", createSessionUrl, bytes.NewBuffer([]byte("{}")))
	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", "application/json")

	resp, _ := client.Do(req)
	body, _ := ioutil.ReadAll(resp.Body)
	resp.Body.Close()

	if resp.StatusCode == 200 || resp.StatusCode == 201 {
		fmt.Println("Session created successfully:", string(body))
		var jsonResponse map[string]interface{}
		json.Unmarshal(body, &jsonResponse)
		sessionID := jsonResponse["session"].(map[string]interface{})["session_id"].(string)

		// Retrieve Session
		getSessionUrl := fmt.Sprintf("%s/%s/sessions/%s", apiBaseUrl, knowledgeBaseId, sessionID)
		req, _ = http.NewRequest("GET", getSessionUrl, nil)
		req.Header.Set("Authorization", "Bearer "+apiKey)

		resp, _ = client.Do(req)
		body, _ = ioutil.ReadAll(resp.Body)
		resp.Body.Close()
		fmt.Println("Session retrieved successfully:", string(body))

		// Send Message
		sendMessageUrl := fmt.Sprintf("%s/%s/sessions/%s", apiBaseUrl, knowledgeBaseId, sessionID)
		messagePayload := map[string]string{"query": "never gonna give you up"}
		jsonMessage, _ := json.Marshal(messagePayload)

		req, _ = http.NewRequest("POST", sendMessageUrl, bytes.NewBuffer(jsonMessage))
		req.Header.Set("Authorization", "Bearer "+apiKey)
		req.Header.Set("Content-Type", "application/json")

		resp, _ = client.Do(req)
		body, _ = ioutil.ReadAll(resp.Body)
		resp.Body.Close()
		fmt.Println("Message sent successfully. AI Response:", string(body))
	} else {
		fmt.Println("Failed to create session.")
	}
}




<?php
$api_base_url = "https://api.tor.app/developer/ai_chat/knowledgebases";
$api_key = "your_api_key";
$knowledge_base_id = "your_knowledgebase_id";

// Set headers
$headers = [
    "Authorization: Bearer $api_key",
    "Content-Type: application/json",
    "Accept: application/json"
];

// POST - Create session
$create_session_url = "$api_base_url/$knowledge_base_id/sessions";
$session_response = json_decode(sendRequest($create_session_url, "POST", $headers, "{}"), true);

if (isset($session_response["session"]["session_id"])) {
    $session_id = $session_response["session"]["session_id"];
    echo "Session created successfully: " . json_encode($session_response, JSON_PRETTY_PRINT) . PHP_EOL;

    // GET - Retrieve session
    $get_session_url = "$api_base_url/$knowledge_base_id/sessions/$session_id";
    $get_response = sendRequest($get_session_url, "GET", $headers);
    echo "Session retrieved successfully: " . $get_response . PHP_EOL;

    // POST - Send message
    $send_message_url = "$api_base_url/$knowledge_base_id/sessions/$session_id";
    $message_payload = json_encode(["query" => "never gonna give you up"]);
    $message_response = sendRequest($send_message_url, "POST", $headers, $message_payload);
    echo "Message sent successfully: " . $message_response . PHP_EOL;
} else {
    echo "Failed to create session." . PHP_EOL;
}

function sendRequest($url, $method, $headers, $body = null) {
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    if ($body) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, $body);
    }
    $response = curl_exec($ch);
    curl_close($ch);
    return $response;
}
?>




<?php
$api_base_url = "https://api.tor.app/developer/ai_chat/knowledgebases";
$api_key = "your_api_key";
$knowledge_base_id = "your_knowledgebase_id";

// Set headers
$headers = [
    "Authorization: Bearer $api_key",
    "Content-Type: application/json",
    "Accept: application/json"
];

// POST - Create session
$create_session_url = "$api_base_url/$knowledge_base_id/sessions";
$session_response = json_decode(sendRequest($create_session_url, "POST", $headers, "{}"), true);

if (isset($session_response["session"]["session_id"])) {
    $session_id = $session_response["session"]["session_id"];
    echo "Session created successfully: " . json_encode($session_response, JSON_PRETTY_PRINT) . PHP_EOL;

    // GET - Retrieve session
    $get_session_url = "$api_base_url/$knowledge_base_id/sessions/$session_id";
    $get_response = sendRequest($get_session_url, "GET", $headers);
    echo "Session retrieved successfully: " . $get_response . PHP_EOL;

    // POST - Send message
    $send_message_url = "$api_base_url/$knowledge_base_id/sessions/$session_id";
    $message_payload = json_encode(["query" => "never gonna give you up"]);
    $message_response = sendRequest($send_message_url, "POST", $headers, $message_payload);
    echo "Message sent successfully: " . $message_response . PHP_EOL;
} else {
    echo "Failed to create session." . PHP_EOL;
}

function sendRequest($url, $method, $headers, $body = null) {
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    if ($body) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, $body);
    }
    $response = curl_exec($ch);
    curl_close($ch);
    return $response;
}
?>



import okhttp3.*
import org.json.JSONObject
import java.io.IOException

val API_BASE_URL = "https://api.tor.app/developer/ai_chat/knowledgebases"
val API_KEY = "your_api_key"
val KNOWLEDGE_BASE_ID = "your_knowledgebase_id"

val client = OkHttpClient()
val headers = Headers.Builder()
    .add("Authorization", "Bearer $API_KEY")
    .add("Content-Type", "application/json")
    .add("Accept", "application/json")
    .build()

fun main() {
    createSession()
}

fun createSession() {
    val createSessionUrl = "$API_BASE_URL/$KNOWLEDGE_BASE_ID/sessions"
    val request = Request.Builder()
        .url(createSessionUrl)
        .post(RequestBody.create(MediaType.parse("application/json"), "{}"))
        .headers(headers)
        .build()

    client.newCall(request).enqueue(object : Callback {
        override fun onFailure(call: Call, e: IOException) {
            println("Failed to create session: ${e.message}")
        }

        override fun onResponse(call: Call, response: Response) {
            response.body()?.let { responseBody ->
                val json = JSONObject(responseBody.string())
                val sessionId = json.getJSONObject("session").getString("session_id")
                println("Session created successfully: $json")
                getSession(sessionId)
            }
        }
    })
}

fun getSession(sessionId: String) {
    val getSessionUrl = "$API_BASE_URL/$KNOWLEDGE_BASE_ID/sessions/$sessionId"
    val request = Request.Builder()
        .url(getSessionUrl)
        .get()
        .headers(headers)
        .build()

    client.newCall(request).enqueue(object : Callback {
        override fun onFailure(call: Call, e: IOException) {
            println("Failed to retrieve session: ${e.message}")
        }

        override fun onResponse(call: Call, response: Response) {
            println("Session retrieved successfully: ${response.body()?.string()}")
            sendMessage(sessionId)
        }
    })
}

fun sendMessage(sessionId: String) {
    val sendMessageUrl = "$API_BASE_URL/$KNOWLEDGE_BASE_ID/sessions/$sessionId"
    val messagePayload = JSONObject().put("query", "never gonna give you up").toString()
    val request = Request.Builder()
        .url(sendMessageUrl)
        .post(RequestBody.create(MediaType.parse("application/json"), messagePayload))
        .headers(headers)
        .build()

    client.newCall(request).enqueue(object : Callback {
        override fun onFailure(call: Call, e: IOException) {
            println("Failed to send message: ${e.message}")
        }

        override fun onResponse(call: Call, response: Response) {
            println("Message sent successfully: ${response.body()?.string()}")
        }
    })
}




import Foundation

let apiBaseUrl = "https://api.tor.app/developer/ai_chat/knowledgebases"
let apiKey = "your_api_key"
let knowledgeBaseId = "your_knowledgebase_id"

var sessionID: String?

var headers = [
    "Authorization": "Bearer \(apiKey)",
    "Content-Type": "application/json",
    "Accept": "application/json"
]

func sendRequest(url: String, method: String, body: Data?, completion: @escaping (Data?) -> Void) {
    var request = URLRequest(url: URL(string: url)!)
    request.httpMethod = method
    headers.forEach { request.setValue($1, forHTTPHeaderField: $0) }
    request.httpBody = body

    URLSession.shared.dataTask(with: request) { data, _, _ in
        completion(data)
    }.resume()
}

// Create session
sendRequest(url: "\(apiBaseUrl)/\(knowledgeBaseId)/sessions", method: "POST", body: nil) { data in
    if let data = data, let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
       let session = json["session"] as? [String: Any], let id = session["session_id"] as? String {
        sessionID = id
        print("Session created successfully: \(json)")
        
        // Retrieve session
        sendRequest(url: "\(apiBaseUrl)/\(knowledgeBaseId)/sessions/\(id)", method: "GET", body: nil) { data in
            print("Session retrieved successfully: \(String(describing: data))")
            
            // Send message
            let messagePayload = try? JSONSerialization.data(withJSONObject: ["query": "never gonna give you up"])
            sendRequest(url: "\(apiBaseUrl)/\(knowledgeBaseId)/sessions/\(id)", method: "POST", body: messagePayload) { data in
                print("Message sent successfully: \(String(describing: data))")
            }
        }
    }
}




import 'dart:convert';
import 'package:http/http.dart' as http;

const String apiBaseUrl = "https://api.tor.app/developer/ai_chat/knowledgebases";
const String apiKey = "your_api_key";
const String knowledgeBaseId = "your_knowledgebase_id";

Map<String, String> headers = {
  "Authorization": "Bearer $apiKey",
  "Content-Type": "application/json",
  "Accept": "application/json",
};

void main() async {
  // Create session
  var createSessionResponse = await http.post(
    Uri.parse("$apiBaseUrl/$knowledgeBaseId/sessions"),
    headers: headers,
  );

  if (createSessionResponse.statusCode == 200 || createSessionResponse.statusCode == 201) {
    var jsonResponse = jsonDecode(createSessionResponse.body);
    String sessionId = jsonResponse["session"]["session_id"];
    print("Session created successfully: $jsonResponse");

    // Retrieve session
    var getSessionResponse = await http.get(
      Uri.parse("$apiBaseUrl/$knowledgeBaseId/sessions/$sessionId"),
      headers: headers,
    );
    print("Session retrieved successfully: ${getSessionResponse.body}");

    // Send message
    var messageResponse = await http.post(
      Uri.parse("$apiBaseUrl/$knowledgeBaseId/sessions/$sessionId"),
      headers: headers,
      body: jsonEncode({"query": "never gonna give you up"}),
    );
    print("Message sent successfully: ${messageResponse.body}");
  } else {
    print("Failed to create session.");
  }
}

Updated about 16 hours ago