Documentation

const API_KEY = 'your-api-key-here';
const BASE_URL = 'https://api.oryxen.ai/v1';

const response = await fetch(`${BASE_URL}/chat/completions`, {
    method: 'POST',
    headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        model: 'oryxen-llm',
        messages: [
            { role: 'user', content: 'Hello, how are you?' }
        ]
    })
});

const data = await response.json();
console.log(data.choices[0].message.content);

curl https://api.oryxen.ai/v1/chat/completions \
  -H "Authorization: Bearer your-api-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "oryxen-llm",
    "messages": [
      {"role": "user", "content": "Hello, how are you?"}
    ]
  }'

package main

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

const API_KEY = "your-api-key-here"
const BASE_URL = "https://api.oryxen.ai/v1"

func main() {
    payload := map[string]interface{}{
        "model": "oryxen-llm",
        "messages": []map[string]string{
            {"role": "user", "content": "Hello, how are you?"},
        },
    }
    
    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", BASE_URL+"/chat/completions", bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer "+API_KEY)
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result["choices"].([]interface{})[0].(map[string]interface{})["message"].(map[string]interface{})["content"])
}

use reqwest::Client;
use serde_json::json;

const API_KEY: &str = "your-api-key-here";
const BASE_URL: &str = "https://api.oryxen.ai/v1";

#[tokio::main]
async fn main() -> Result<(), Box> {
    let client = Client::new();
    
    let response = client
        .post(format!("{}/chat/completions", BASE_URL))
        .header("Authorization", format!("Bearer {}", API_KEY))
        .header("Content-Type", "application/json")
        .json(&json!({
            "model": "oryxen-llm",
            "messages": [{"role": "user", "content": "Hello, how are you?"}]
        }))
        .send()
        .await?;
    
    let data: serde_json::Value = response.json().await?;
    println!("{}", data["choices"][0]["message"]["content"]);
    
    Ok(())
}

{-# LANGUAGE OverloadedStrings #-}

import Network.HTTP.Simple
import Data.Aeson
import qualified Data.ByteString.Char8 as B

apiKey :: B.ByteString
apiKey = "Bearer your-api-key-here"

baseUrl :: String
baseUrl = "https://api.oryxen.ai/v1/chat/completions"

main :: IO ()
main = do
    let request = setRequestMethod "POST"
                $ setRequestHeader "Authorization" [apiKey]
                $ setRequestHeader "Content-Type" ["application/json"]
                $ setRequestBodyJSON payload
                $ parseRequest_ baseUrl
    
    response <- httpJSON request
    print (getResponseBody response :: Value)
  where
    payload = object ["model" .= "oryxen-llm",
                      "messages" .= [object ["role" .= "user", "content" .= "Hello!"]]]

using HTTP
using JSON3

const API_KEY = "your-api-key-here"
const BASE_URL = "https://api.oryxen.ai/v1"

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

payload = Dict(
    "model" => "oryxen-llm",
    "messages" => [
        Dict("role" => "user", "content" => "Hello, how are you?")
    ]
)

response = HTTP.post(
    "$BASE_URL/chat/completions",
    headers,
    JSON3.write(payload)
)

data = JSON3.read(String(response.body))
println(data.choices[1].message.content)