npm install openai cohere-ai langchain
  @langchain/core @langchain/openai @langchain/cohere

go get github.com/openai/openai-go
  github.com/cohere-ai/cohere-go/v2

from openai import OpenAI
from urllib.parse import urljoin

aios_base_url = "<<aios endpoint-url>>" # Enter the aios endpoint URL for calling the AIOS model.
model = "<<model>>"                     # Enter the model ID for calling the AIOS model.

# Create an OpenAI client.
# base_url refers to the v1 endpoint of the AIOS API,
# api_key is the key required by AIOS, and it is typically set to "EMPTY_KEY".
client = OpenAI(base_url=urljoin(aios_base_url, "v1"), api_key="EMPTY_KEY")

# Generate completions using the AIOS model.
# The model parameter specifies the model ID to use,
# The prompt parameter is the input text provided to the AI.
response = client.completions.create(
  model=model,
  prompt="Hi"
)

# response.choices[0].text is the response text generated by the AI model.
print(response.choices[0].text)

from langchain_openai import OpenAI
from urllib.parse import urljoin

aios_base_url = "<<aios endpoint-url>>" # Enter the aios endpoint URL for calling the AIOS model.
model = "<<model>>"                     # Enter the model ID for calling the AIOS model.

# Create an LLM (large language model) instance using LangChain's OpenAI class.
# base_url refers to the v1 endpoint of the AIOS API,
# api_key is the key required by AIOS, and it is typically set to "EMPTY_KEY".
# The model parameter specifies the model ID to use.
llm = OpenAI(
  base_url=urljoin(aios_base_url, "v1"),
  api_key="EMPTY_KEY",
  model=model
)

# Pass the prompt "Hi" to the LLM and receive a response.
# The invoke method returns the model's output.
print(llm.invoke("Hi"))

const aios_base_url = "<<aios endpoint-url>>" // Enter the aios endpoint URL for calling the AIOS model.
const model = "<<model>>"                     // Enter the model ID for invoking the AIOS model.

// Construct the request data.
// This includes the model ID to be used and the prompt (prompt).
const data = {
  model: model,
  prompt: "Hi"
};

// Generate the URL for the AIOS API v1/completions endpoint.
let url = new URL("/v1/completions", aios_base_url);

// Send a POST request to the AIOS API.
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: JSON.stringify(data),
});

// Parse the response body as JSON.
const body = await response.json();

// The choices[0].text in the response body is the response text generated by the AI model.
console.log(body.choices[0].text);

import OpenAI from "openai";

const aios_base_url = "<<aios endpoint-url>>" // Enter the aios endpoint URL for calling the AIOS model.
const model = "<<model>>"                     // Enter the model ID to invoke the AIOS model.

// Create an OpenAI client.
// apiKey is the key required by AIOS, typically set to "EMPTY_KEY".
// baseURL points to the v1 endpoint of the AIOS API.
const client = new OpenAI({
  apiKey: "EMPTY_KEY",
  baseURL: new URL("v1", aios_base_url).href,
});

// Generate a completion using the AIOS model.
// model parameter specifies the model ID to use,
// prompt parameter is the input text provided to the AI.
const completions = await client.completions.create({
  model: model,
  prompt: "Hi"
});

// The choices[0].text in the response body is the response text generated by the AI model.
console.log(completions.choices[0].text);

import { OpenAI } from "@langchain/openai";

const aios_base_url = "<<aios endpoint-url>>" // Enter the aios endpoint URL for calling the AIOS model.
const model = "<<model>>"                     // Enter the model ID to call the AIOS model.

// Create an LLM (large language model) instance using LangChain's OpenAI class.
// model parameter specifies the model ID to use.
// apiKey is the key required by AIOS, and is typically set to "EMPTY_KEY".
// configuration.baseURL points to the v1 endpoint of the AIOS API.
const llm = new OpenAI({
  model: model,
  apiKey: "EMPTY_KEY",
  configuration: {
    baseURL: new URL("v1", aios_base_url).href,
  },
});

// Send the prompt "Hi" to the LLM and receive a response.
// invoke method returns the model's output.
const completion = await llm.invoke("Hi");

// Print the generated response.
// This text is a response generated by an AI model.
console.log(completion);

package main

import (
	bytes
	"encoding/json"
	"fmt"
	io
	"net/http"
)
const (
	aiosBaseUrl = "<<aios endpoint-url>>" // Enter the aios endpoint URL for calling the AIOS model.
	model = "<<model>>"                   // Enter the model ID for calling the AIOS model.
)

// Define the data structure to be used for POST requests.
// Model: model ID to use
// Prompt: Input text to provide to the AI
// Stream: streaming response flag (optional)
type PostData struct {
	Model string `json:"model"`
	Prompt string `json:"prompt"`
	Stream bool `json:"stream,omitempty"`
}

func main() {
	// Generate request data.
	data := PostData{
		Model: model,
		Prompt: "Hi",
	}

	// Marshal the data into JSON format.
	jsonData, err := json.Marshal(data)
	if err != nil {
		panic(err)
	}

	// Send a POST request to the AIOS API's v1/completions endpoint.
	response, err := http.Post(aiosBaseUrl + "/v1/completions", "application/json", bytes.NewBuffer(jsonData))
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	// Read the entire response body.
	body, err := io.ReadAll(response.Body)
	if err != nil {
		panic(err)
	}

	var v map[string]interface{}
	json.Unmarshal(body, &v)
	// Extract the choices array from the response.
	choices := v["choices"].([]interface{})
	// Extract the text of the first data.
	choice := choices[0].(map[string]interface{})
	text := choice["text"]
	// Print the response text generated by the AI model.
	fmt.Println(text)
}

package main

import (
	context
	fmt

	"github.com/openai/openai-go"
	github.com/openai/openai-go/option
	github.com/openai/openai-go/packages/param
)

const (
	aiosBaseUrl = "<<aios endpoint-url>>" // Enter the aios endpoint URL for invoking the AIOS model.
	model = "<<model>>"                   // Enter the model ID for invoking the AIOS model.
)

func main() {
	// Create an OpenAI client.
	// Set the v1 endpoint of the AIOS API using option.WithBaseURL.
	client := openai.NewClient(
		option.WithBaseURL(aiosBaseUrl+"/v1"),
	)

	// Generate completion using the AIOS model.
	// Set the model and prompt using openai.CompletionNewParams.
	completion, err := client.Completions.New(context.TODO(), openai.CompletionNewParams{
		Model:  openai.CompletionNewParamsModel(model),
		Prompt: openai.CompletionNewParamsPromptUnion{OfString: param.Opt[string]{Value: "Hi"}},
	})

	if err != nil {
		panic(err)
	}

	// The choices[0].text in the response body is the response text generated by the AI model.
	fmt.Println(completion.Choices[0].Text)
}

from openai import OpenAI
from urllib.parse import urljoin

aios_base_url = "<<aios endpoint-url>>" # Enter the aios endpoint URL for calling the AIOS model.
model = "<<model>>"                     # Enter the model ID for calling the AIOS model.

# Create an OpenAI client.
# base_url refers to the v1 endpoint of the AIOS API,
# api_key is the key required by AIOS, and it is typically set to "EMPTY_KEY".
client = OpenAI(base_url=urljoin(aios_base_url, "v1"), api_key="EMPTY_KEY")

# Generate completions using the AIOS model.
# The model parameter specifies the model ID to use,
# The prompt parameter is the input text provided to the AI.
# Set stream=True to receive real-time streaming responses.
response = client.completions.create(
  model=model,
  prompt="Hi"
  stream=True
)

# You can receive it as a response each time the model generates a token.
# Since the response is sent as a stream, it can be processed iteratively.
for chunk in response:
  # In each chunk, choices[0].text is the response text generated by the AI model.
  print(chunk.choices[0].text)

from langchain_openai import OpenAI
from urllib.parse import urljoin

aios_base_url = "<<aios endpoint-url>>" # Enter the aios endpoint URL for calling the AIOS model.
model = "<<model>>"                     # Enter the model ID for calling the AIOS model.

# Create an LLM (large language model) instance using LangChain's OpenAI class.
# base_url refers to the v1 endpoint of the AIOS API,
# api_key is the key required by AIOS, and it is typically set to "EMPTY_KEY".
# The model parameter specifies the model ID to use.
llm = OpenAI(
  base_url=urljoin(aios_base_url, "v1"),
  api_key="EMPTY_KEY",
  model=model
)

# Send the prompt "Hi" to the LLM and receive a streaming response.
# The stream method returns a stream that generates tokens in real time.
response = llm.stream("Hi")

# You can receive it as a response each time the model generates a token.
# Since the response is transmitted as a stream, it can be processed iteratively.
for chunk in response:
  # Print each chunk.
  # This chunk is a response token generated by the AI model.
  print(chunk)

const aios_base_url = "<<aios endpoint-url>>" // Enter the aios endpoint URL for calling the AIOS model.
const model = "<<model>>"                     // Enter the model ID to invoke the AIOS model.

// Construct the request data.
// This contains the model ID to use, the prompt (prompt), and the streaming option (stream).
const data = {
  model: model,
  prompt: "Hi"
  stream: true,
};

// Generate the v1/completions endpoint URL of the AIOS API.
let url = new URL("/v1/completions", aios_base_url);

// Send a POST request to the AIOS API.
// Set stream: true to receive real-time streaming responses.
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: JSON.stringify(data),
});

// You can receive it as a response each time the model generates a token.
// Convert the response body to a text decoder stream and read it.
const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
let buf = "";
while (true) {
  const { value, done } = await reader.read();
  if (done) break;

  // Add the received data to the buffer.
  buf += value;
  let sep;
  // Find newline characters (\n\n) in the buffer and split the data.
  while ((sep = buf.indexOf("\n\n")) >= 0) {
    const data = buf.slice(0, sep);
    buf = buf.slice(sep + 2);

	// Process each line.
    for (const rawLine of data.split("\n")) {
      const line = rawLine.trim();
      if (!line.startsWith("data: ")) continue;

      // "data: " Remove the prefix and extract the JSON data.
      const payload = line.slice("data: ".length).trim();
      if (payload === "[DONE]") break;

	  // Parse JSON data.
      const json = JSON.parse(payload);
	  // choices[0].text is the response text generated by the AI model.
      console.log(json.choices[0].text);
    }
  }
}

import OpenAI from "openai";

const aios_base_url = "<<aios endpoint-url>>" // Enter the aios endpoint URL for calling the AIOS model.
const model = "<<model>>"                     // Enter the model ID to call the AIOS model.

// Create an OpenAI client.
// apiKey is the key required by AIOS, and is typically set to "EMPTY_KEY".
// baseURL points to the v1 endpoint of the AIOS API.
const client = new OpenAI({
  apiKey: "EMPTY_KEY","
  baseURL: new URL("v1", aios_base_url).href,
});

// Generate completion using the AIOS model.
// model parameter specifies the model ID to use,
// prompt parameter is the input text provided to the AI.
// Set stream: true to receive real-time streaming responses.
const completions = await client.completions.create({
  model: model,
  prompt: "Hi"
  stream: true,
});

// You can receive it as a response each time the model generates a token.
// Process stream events sequentially using a for await...of loop.
for await (const event of completions) {
  // The choices[0].text of each event is the response text generated by the AI model.
  console.log(event.choices[0].text);
}

import { OpenAI } from "@langchain/openai";

const aios_base_url = "<<aios endpoint-url>>" // Enter the aios endpoint URL for calling the AIOS model.
const model = "<<model>>"                     // Enter the model ID to invoke the AIOS model.

// Create an LLM (large language model) instance using LangChain's OpenAI class.
// model parameter specifies the model ID to use.
// apiKey is the key required by AIOS, and is typically set to "EMPTY_KEY".
// configuration.baseURL points to the v1 endpoint of the AIOS API.
const llm = new OpenAI({
  model: model,
  apiKey: "EMPTY_KEY","
  configuration: {
    baseURL: new URL("v1", aios_base_url).href,
  },
});

// Send the prompt "Hi" to the LLM and receive a streaming response.
// stream method returns a stream that generates tokens in real time.
const completion = await llm.stream("Hi");

// You can receive it as a response each time the model generates a token.
// for await...of loop processes stream chunks sequentially.
for await (const chunk of completion) {
  // Print each chunk.
  // This chunk is a response token generated by the AI model.
  console.log(chunk);
}

package main

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

const (
	aiosBaseUrl = "<<aios endpoint-url>>" // Enter the aios endpoint URL for calling the AIOS model.
	model = "<<model>>"                   // Enter the model ID for invoking the AIOS model.
)

// Define the data structure to be used for POST requests.
// Model: model ID to use
// Prompt: input text to provide to the AI
// Stream: streaming response (optional)
type PostData struct {
	Model  string `json:"model"`
	Prompt string `json:"prompt"`
	Stream bool   `json:"stream,omitempty"`
}

func main() {
	// Generate request data.
	// Set Stream: true to receive real-time streaming responses.
	data := PostData{
		Model:  model,
		Prompt: "Hi",
		Stream: true,
	}

	// Marshal the data into JSON format.
	jsonData, err := json.Marshal(data)
	if err != nil {
		panic(err)
	}

	// Send a POST request to the AIOS API's v1/completions endpoint.
	response, err := http.Post(aiosBaseUrl+"/v1/completions", "application/json", bytes.NewBuffer(jsonData))
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	// You can receive it as a response each time the model generates a token.
	// Scan the HTTP response body and process it line by line.
	var v map[string]interface{}
	scanner := bufio.NewScanner(response.Body)
	for scanner.Scan() {
		line := bytes.TrimSpace(scanner.Bytes())

		// Skip if the line does not start with "data: "
		if !bytes.HasPrefix(line, []byte("data: ")) {
			continue
		}

		// Remove the "data: " prefix.
		payload := bytes.TrimPrefix(line, []byte("data: "))

		// If the payload is "[DONE]", terminate the streaming.
		if bytes.Equal(payload, []byte("[DONE]")) {
			break
		}

		// Parse JSON data.
		json.Unmarshal(payload, &v)
		// Extract the choices array from the response.
		choices := v["choices"].([]interface{})
		// Extract the first data.
		choice := choices[0].(map[string]interface{})
		// Extract response tokens generated by the AI model.
		text := choice["text"]
		fmt.Println(text)
	}
}

package main

import (
	context
	fmt

	"github.com/openai/openai-go"
	github.com/openai/openai-go/option
	github.com/openai/openai-go/packages/param
)

const (
	aiosBaseUrl = "<<aios endpoint-url>>" // Enter the aios endpoint URL for calling the AIOS model.
	model = "<<model>>"                   // Enter the model ID for invoking the AIOS model.
)

func main() {
	// Create an OpenAI client.
	// Set the v1 endpoint of the AIOS API using option.WithBaseURL.
	client := openai.NewClient(
		option.WithBaseURL(aiosBaseUrl + "/v1"),
	)

	// Generate streaming completion using the AIOS model.
	// Set the model and prompt using openai.CompletionNewParams.
	completion := client.Completions.NewStreaming(context.TODO(), openai.CompletionNewParams{
		Model:  openai.CompletionNewParamsModel(model),
		Prompt: openai.CompletionNewParamsPromptUnion{OfString: param.Opt[string]{Value: "Hi"}},
	})

	// You can receive it as a response each time the model generates a token.
	// Next() method returns true when there is a next chunk.
	for completion.Next() {
		// Get the choices slice of the current chunk.
		chunk := completion.Current().Choices
		// choices[0].text is the response text generated by the AI model.
		fmt.Println(chunk[0].Text)
	}
}

from openai import OpenAI
from urllib.parse import urljoin

aios_base_url = "<<aios endpoint-url>>" # Enter the aios endpoint URL for calling the AIOS model.
model = "<<model>>"                     # Enter the model ID for calling the AIOS model.

# Create an OpenAI client.
# base_url refers to the v1 endpoint of the AIOS API,
# api_key is the key required by AIOS, and it is typically set to "EMPTY_KEY".
client = OpenAI(base_url=urljoin(aios_base_url, "v1"), api_key="EMPTY_KEY")

# Generate chat completions using the AIOS model.
# The model parameter specifies the model ID to use.
# The messages parameter is a list of messages that includes system messages and user messages.
response = client.chat.completions.create(
  model=model,
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    Hi
  ]
)

# Print choices[0].message from the generated response.
print(response.choices[0].message.model_dump())

from langchain_openai import ChatOpenAI
from urllib.parse import urljoin

aios_base_url = "<<aios endpoint-url>>" # Enter the aios endpoint URL for calling the AIOS model.
model = "<<model>>"                     # Enter the model ID for calling the AIOS model.

# Create a chat LLM (large language model) instance using LangChain's ChatOpenAI class.
# base_url refers to the v1 endpoint of the AIOS API,
# api_key is the key required by AIOS, and it is typically set to "EMPTY_KEY".
# The model parameter specifies the model ID to use.
chat_llm = ChatOpenAI(
  base_url=urljoin(aios_base_url, "v1"),
  api_key="EMPTY_KEY",
  model=model
)

# Construct the chat message list.
# Includes system messages and user messages.
messages = [
    ("system", "You are a helpful assistant.")
    ("human", "Hi"),
]

# Pass a list of messages to the chat LLM and receive a response.
# The invoke method returns the model's output.
chat_completion = chat_llm.invoke(messages)

# Print the generated response.
print(chat_completion.model_dump())

const aios_base_url = "<<aios endpoint-url>>"; // Enter the aios endpoint URL for calling the AIOS model.
const model = "<<model>>";                     // Enter the model ID to call the AIOS model.

// Construct the request data.
// This includes the model ID to be used and the list of messages (messages).
// The message list includes system messages and user messages.
const data = {
  model: model,
  messages: [
    { role: "system", content: "You are a helpful assistant." }
    { role: "user", content: "Hi" }
  ],
};

// Generate the URL for the AIOS API v1/chat/completions endpoint.
let url = new URL("/v1/chat/completions", aios_base_url);

// Send a POST request to the AIOS API.
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: JSON.stringify(data),
});

// Parse the response body as JSON.
const body = await response.json();
// Print choices[0].message from the generated response.
console.log(body.choices[0].message);

import OpenAI from "openai";

const aios_base_url = "<<aios endpoint-url>>"; // Enter the aios endpoint URL for calling the AIOS model.
const model = "<<model>>";                     // Enter the model ID for invoking the AIOS model.

// Create an OpenAI client.
// apiKey is the key required by AIOS, and is typically set to "EMPTY_KEY".
// baseURL points to the v1 endpoint of the AIOS API.
const client = new OpenAI({
  apiKey: "EMPTY_KEY","
  baseURL: new URL("v1", aios_base_url).href,
});

// Generate chat completion using the AIOS model.
// model parameter specifies the model ID to use.
// messages parameter is a list of messages that includes system messages and user messages.
const response = await client.chat.completions.create({
  model: model,
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Hi" }
  ],
});

// Print choices[0].message from the generated response.
console.log(response.choices[0].message);

import { HumanMessage, SystemMessage } from "@langchain/core/messages";
import { ChatOpenAI } from "@langchain/openai";

const aios_base_url = "<<aios endpoint-url>>"; // Enter the aios endpoint URL for calling the AIOS model.
const model = "<<model>>";                     // Enter the model ID to call the AIOS model.

// Create a chat LLM (large language model) instance using LangChain's ChatOpenAI class.
// model parameter specifies the model ID to use.
// apiKey is the key required by AIOS, typically set to "EMPTY_KEY".
// configuration.baseURL points to the v1 endpoint of the AIOS API.
const llm = new ChatOpenAI({
  model: model,
  apiKey: "EMPTY_KEY","
  configuration: {
    baseURL: new URL("v1", aios_base_url).href,
  },
});

// Constructs the chat message list.
// Include system messages and user messages using SystemMessage and HumanMessage objects.
const messages = [
  new SystemMessage("You are a helpful assistant.")
  new HumanMessage("Hi"),
];

// Pass a list of messages to the chat LLM to receive a response.
// invoke method returns the model's output.
const response = await llm.invoke(messages);

// Print the generated response's content (content).
// This content is a response text generated by an AI model.
console.log(response.content);

package main

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

const (
	aiosBaseUrl = "<<aios endpoint-url>>" // Enter the aios endpoint URL for calling the AIOS model.
	model = "<<model>>"                   // Enter the model ID for invoking the AIOS model.
)

// Define the message structure.
// Role: message role (e.g., system, user)
// Content: message content
type Message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

// Define the data structure used for POST requests.
// Model: model ID to use
// Messages: Message list
// Stream: streaming response (optional)
type PostData struct {
	Model    string    `json:"model"`
	Messages []Message `json:"messages"`
	Stream   bool      `json:"stream,omitempty"`
}

func main() {
	// Generate request data.
	// The message list includes system messages and user messages.
	data := PostData{
		Model: model,
		Messages: []Message{
			{
				Role:    "system",
				You are a helpful assistant.
			},
			{
				Role:    "user",
				Content: "Hi"
			},
		},
	}

	// Marshal the data into JSON format.
	jsonData, err := json.Marshal(data)
	if err != nil {
		panic(err)
	}

	// Send a POST request to the AIOS API's v1/chat/completions endpoint.
	response, err := http.Post(aiosBaseUrl+"/v1/chat/completions", "application/json", bytes.NewBuffer(jsonData))
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	// Read the entire response body.
	body, err := io.ReadAll(response.Body)
	if err != nil {
		panic(err)
	}

	// Unmarshal the response body into a map.
	var v map[string]interface{}
	json.Unmarshal(body, &v)
	// Extract the choices array from the response.
	choices := v["choices"].([]interface{})
	// Extract the first data.
	choice := choices[0].(map[string]interface{})
	// Formats and outputs the response message generated by the AI model in JSON format.
	message, err := json.MarshalIndent(choice["message"], "", "  ")
	if err != nil {
		panic(err)
	}
	fmt.Println(string(message))
}

package main

import (
	context
	fmt

	"github.com/openai/openai-go"
	github.com/openai/openai-go/option
)

const (
	aiosBaseUrl = "<<aios endpoint-url>>" // Enter the aios endpoint URL for calling the AIOS model.
	model = "<<model>>"                   // Enter the model ID for invoking the AIOS model.
)

func main() {
	// Create an OpenAI client.
	// Set the v1 endpoint of the AIOS API using option.WithBaseURL.
	client := openai.NewClient(
		option.WithBaseURL(aiosBaseUrl + "/v1"),
	)

	// Generate chat completion using the AIOS model.
	// Set the model and message list using openai.ChatCompletionNewParams.
	// The message list includes system messages and user messages.
	response, err := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
		Model: model,
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.SystemMessage("You are a helpful assistant.")
			openai.UserMessage("Hi"),
		},
	})

	if err != nil {
		panic(err)
	}

	// Format and output the response message generated by the AI model in JSON format.
	fmt.Println(response.Choices[0].Message.RawJSON())
}