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 points to the v1 endpoint of the AIOS API,
# api_key is the key required by AIOS, typically set to "EMPTY_KEY".
client = OpenAI(base_url=urljoin(aios_base_url, "v1"), api_key="EMPTY_KEY")

# Generate a completion using the AIOS model.
# model parameter specifies the model ID to use,
# prompt parameter is the input text to provide 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 points to the v1 endpoint of the AIOS API,
# api_key is the key required by AIOS, typically set to "EMPTY_KEY".
# 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 calling the AIOS model.

// Configure the request data.
// This includes the model ID to use and the prompt.
const data = {
  model: model,
  prompt: "Hi",
};

// Create the AIOS API's v1/completions endpoint URL.
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 in JSON format.
const body = await response.json();

// response.choices[0].text 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 for calling 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 to provide to the AI.
const completions = await client.completions.create({
  model: model,
  prompt: "Hi",
});

// response.choices[0].text 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 for calling 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, 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,
  },
});

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

// Output the generated response.
// This text is the response generated by the 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: Whether to stream response (optional)
type PostData struct {
	Model string `json:"model"`
	Prompt string `json:"prompt"`
	Stream bool `json:"stream,omitempty"`
}

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

	// Marshal data to 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 first data's text.
	choice := choices[0].(map[string]interface{})
	text := choice["text"]
	// Output 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 calling the AIOS model.
	model = "<<model>>"                   // Enter the model ID for calling the AIOS model.
)

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

	// Generate a completion using the AIOS model.
	// Use openai.CompletionNewParams to set the model and prompt.
	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)
	}

	// response.choices[0].text 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 points to the v1 endpoint of the AIOS API,
# api_key is the key required by AIOS, typically set to "EMPTY_KEY".
client = OpenAI(base_url=urljoin(aios_base_url, "v1"), api_key="EMPTY_KEY")

# Generate a completion using the AIOS model.
# model parameter specifies the model ID to use,
# prompt parameter is the input text to provide 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 responses as the model generates tokens.
# response is sent in stream format, so you can process it iteratively.
for chunk in response:
  # Each chunk's 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 points to the v1 endpoint of the AIOS API,
# api_key is the key required by AIOS, typically set to "EMPTY_KEY".
# 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 streaming response.
# The stream method returns a stream that generates tokens in real-time.
response = llm.stream("Hi")

# You can receive responses as the model generates tokens.
# response is sent in stream format, so you can process it iteratively.
for chunk in response:
  # Output each chunk.
  # This chunk is the 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 for calling the AIOS model.

// Configure the request data.
// This includes the model ID to use, the prompt, and whether to stream.
const data = {
  model: model,
  prompt: "Hi",
  stream: true,
};

// Create the AIOS API's v1/completions endpoint URL.
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 responses as the model generates tokens.
// 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 received data to buffer.
  buf += value;
  let sep;
  // Find newline characters (\n\n) in the buffer and separate 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;

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

	  // Parse the 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 for calling 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 to provide 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 responses as the model generates tokens.
// Use for await...of loop to sequentially process stream events.
for await (const event of completions) {
  // Each event's choices[0].text 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 for calling 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, 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,
  },
});

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

// You can receive responses as the model generates tokens.
// Use for await...of loop to sequentially process stream chunks.
for await (const chunk of completion) {
  // Output each chunk.
  // This chunk is the 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 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: Whether to stream response (optional)
type PostData struct {
	Model  string `json:"model"`
	Prompt string `json:"prompt"`
	Stream bool   `json:"stream,omitempty"`
}

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

	// Marshal data to 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 responses as the model generates tokens.
	// Scan the HTTP response body and process line by line.
	var v map[string]interface{}
	scanner := bufio.NewScanner(response.Body)
	for scanner.Scan() {
		line := bytes.TrimSpace(scanner.Bytes())

		// Skip lines that don't start with "data: ".
		if !bytes.HasPrefix(line, []byte("data: ")) {
			continue
		}

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

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

		// Parse the 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 the response token 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 calling the AIOS model.
)

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

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

	// You can receive responses as the model generates tokens.
	// The 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 points to the v1 endpoint of the AIOS API,
# api_key is the key required by AIOS, typically set to "EMPTY_KEY".
client = OpenAI(base_url=urljoin(aios_base_url, "v1"), api_key="EMPTY_KEY")

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

# Output 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 points to the v1 endpoint of the AIOS API,
# api_key is the key required by AIOS, typically set to "EMPTY_KEY".
# model parameter specifies the model ID to use.
chat_llm = ChatOpenAI(
  base_url=urljoin(aios_base_url, "v1"), 
  api_key="EMPTY_KEY", 
  model=model
)

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

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

# Output 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 for calling the AIOS model.

// Configure the request data.
// This includes the model ID to use and the messages list.
// The messages list includes system messages and user messages.
const data = {
  model: model,
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Hi" },
  ],
};

// Create the AIOS API's v1/chat/completions endpoint URL.
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 in JSON format.
const body = await response.json();
// Output 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 calling 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 chat completion using the AIOS model.
// model parameter specifies the model ID to use.
// messages parameter is a list of messages including system 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" },
  ],
});

// Output 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 for calling 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,
  },
});

// Configure the chat messages 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 the messages list to the chat LLM and receive a response.
// The invoke method returns the model's output.
const response = await llm.invoke(messages);

// Output the content of the generated response.
// This content is the response text generated by the 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 calling 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 to be used for POST requests.
// Model: Model ID to use
// Messages: List of messages
// Stream: Whether to stream response (optional)
type PostData struct {
	Model    string    `json:"model"`
	Messages []Message `json:"messages"`
	Stream   bool      `json:"stream,omitempty"`
}

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

	// Marshal data to 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 map format.
	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{})
	// Format and output 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 calling the AIOS model.
)

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

	// Generate a chat completion using the AIOS model.
	// Use openai.ChatCompletionNewParams to set the model and messages list.
	// The messages 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())
}