شروع به کار با هوش مصنوعی Qwen

npm i @ai-sdk/openai@^1 ai@^4

import { createOpenAI } from '@ai-sdk/openai';
import { generateText } from 'ai';

const my_model = createOpenAI({
baseURL: "<baseUrl>",
apiKey: "<LIARA_API_TOKEN>",
});

const { text } = await generateText({
  model: my_model("<model_name>"),
  prompt: 'Why is the sky blue?',
});

console.log('Generated Text:', text);

// npm install openai dotenv
require("dotenv").config();

const fs = require("fs");
const OpenAI = require("openai");

const client = new OpenAI({
apiKey: process.env.LIARA_API_KEY,
baseURL: process.env.BASE_URL,
});

async function main() {
const response = await client.audio.speech.create({
  model: process.env.TTS_MODEL_NAME,
  voice: process.env.TTS_VOICE,
  input: "Hello! This audio was generated using Qwen through Liara.",
  response_format: "mp3",
});

const buffer = Buffer.from(await response.arrayBuffer());

fs.writeFileSync("speech.mp3", buffer);

console.log("Audio saved to speech.mp3");
}

main().catch(console.error);

<?php
// composer require openai-php/client vlucas/phpdotenv guzzlehttp/guzzle

require __DIR__ . '/vendor/autoload.php';

$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
$dotenv->load();

$client = OpenAI::factory()
  ->withApiKey($_ENV["LIARA_API_KEY"])
  ->withBaseUri($_ENV["BASE_URL"])
  ->make();

$audio = $client->audio()->speech([
  "model" => $_ENV["TTS_MODEL_NAME"],
  "voice" => $_ENV["TTS_VOICE"],
  "input" => "Hello! This audio was generated using Qwen through Liara on PHP!!! Ohhhh Yeahhhhh!",
  "response_format" => "mp3",
]);

file_put_contents(
  __DIR__ . "/speech.mp3",
  $audio
);

echo "Audio saved to speech.mp3";

# pip install openai python-dotenv
import os
from pathlib import Path

from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI(
  api_key=os.getenv("LIARA_API_KEY"),
  base_url=os.getenv("BASE_URL"),
)

speech_file = Path("speech.mp3")

with client.audio.speech.with_streaming_response.create(
  model=os.getenv("TTS_MODEL_NAME"),
  voice=os.getenv("TTS_VOICE"),
  input="Hello! This audio was generated using Qwen through Liara on Python! it's awesome, right?",
  response_format="mp3",
) as response:
  response.stream_to_file(speech_file)

print("Audio saved to speech.mp3")

// dotnet add package OpenAI && dotnet add package DotNetEnv
using System.ClientModel;
using DotNetEnv;
using OpenAI;
using OpenAI.Audio;

Env.Load();

var baseUrl = Environment.GetEnvironmentVariable("BASE_URL")
  ?? throw new Exception("BASE_URL is not defined.");

var apiKey = Environment.GetEnvironmentVariable("LIARA_API_KEY")
  ?? throw new Exception("LIARA_API_KEY is not defined.");

var modelName = Environment.GetEnvironmentVariable("TTS_MODEL_NAME")
  ?? throw new Exception("TTS_MODEL_NAME is not defined.");

var voiceName = Environment.GetEnvironmentVariable("TTS_VOICE")
  ?? throw new Exception("TTS_VOICE is not defined.");

var client = new OpenAIClient(
  credential: new ApiKeyCredential(apiKey),
  options: new OpenAIClientOptions
  {
      Endpoint = new Uri(baseUrl)
  }
);

AudioClient audioClient = client.GetAudioClient(modelName);

GeneratedSpeechVoice voice = new(voiceName);

BinaryData speech = await audioClient.GenerateSpeechAsync(
  "Hello! This audio was generated using Qwen through Liara. On DOTNET!!! This is Crazy!!!!",
  voice,
  new SpeechGenerationOptions
  {
      ResponseFormat = GeneratedSpeechFormat.Mp3
  }
);

await File.WriteAllBytesAsync(
  "speech.mp3",
  speech.ToArray()
);

Console.WriteLine("Audio saved to speech.mp3");

// go get github.com/openai/openai-go/v3 github.com/joho/godotenv
package main

import (
"context"
"fmt"
"io"
"os"

"github.com/joho/godotenv"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)

func main() {
err := godotenv.Load()
if err != nil {
	panic("Error loading .env file")
}

baseURL := os.Getenv("BASE_URL")
apiKey := os.Getenv("LIARA_API_KEY")
modelName := os.Getenv("TTS_MODEL_NAME")
voiceName := os.Getenv("TTS_VOICE")

client := openai.NewClient(
	option.WithAPIKey(apiKey),
	option.WithBaseURL(baseURL),
)

response, err := client.Audio.Speech.New(
	context.Background(),
	openai.AudioSpeechNewParams{
		Model: modelName,

		Voice: openai.AudioSpeechNewParamsVoiceUnion{
			OfString: openai.String(voiceName),
		},

		Input: "Hello! This audio was generated using Qwen through Liara. On Go!!!! Hellll Yeahhhh",

		ResponseFormat: openai.AudioSpeechNewParamsResponseFormatMP3,
	},
)

if err != nil {
	panic(err)
}

defer response.Body.Close()

file, err := os.Create("speech.mp3")
if err != nil {
	panic(err)
}

defer file.Close()

_, err = io.Copy(file, response.Body)
if err != nil {
	panic(err)
}

fmt.Println("Audio saved to speech.mp3")
}

// npm install openai dotenv

require("dotenv").config();

const fs = require("fs");
const path = require("path");
const OpenAI = require("openai");
const { toFile } = require("openai");

const client = new OpenAI({
apiKey: process.env.LIARA_API_KEY,
baseURL: process.env.BASE_URL,
});

async function main() {
const audioPath = path.resolve(process.env.AUDIO_FILE);

if (!fs.existsSync(audioPath)) {
  throw new Error(`Audio file not found: ${audioPath}`);
}

const extension = path.extname(audioPath).toLowerCase();

const mimeTypes = {
  ".mp3": "audio/mpeg",
  ".wav": "audio/wav",
  ".flac": "audio/flac",
  ".m4a": "audio/mp4",
  ".ogg": "audio/ogg",
  ".webm": "audio/webm",
  ".aac": "audio/aac",
};

const mimeType = mimeTypes[extension];

if (!mimeType) {
  throw new Error(`Unsupported audio format: ${extension}`);
}

const audioBuffer = fs.readFileSync(audioPath);

const audioFile = await toFile(
  audioBuffer,
  path.basename(audioPath),
  {
    type: mimeType,
  }
);

const transcription = await client.audio.transcriptions.create({
  model: process.env.STT_MODEL_NAME,
  file: audioFile,
});

console.log(transcription.text);
}

main().catch(console.error);

<?php
// composer require openai-php/client vlucas/phpdotenv guzzlehttp/guzzle
require __DIR__ . '/vendor/autoload.php';

$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
$dotenv->load();

$client = OpenAI::factory()
  ->withApiKey($_ENV["LIARA_API_KEY"])
  ->withBaseUri($_ENV["BASE_URL"])
  ->make();

$audioPath = __DIR__ . "/" . $_ENV["AUDIO_FILE"];

if (!file_exists($audioPath)) {
  throw new Exception("Audio file not found: " . $audioPath);
}

$audioFile = fopen($audioPath, "r");

if ($audioFile === false) {
  throw new Exception("Unable to open audio file.");
}

$response = $client->audio()->transcribe([
  "model" => $_ENV["STT_MODEL_NAME"],
  "file" => $audioFile,
]);

echo $response->text;

# pip install openai python-dotenv

import os

from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI(
  api_key=os.getenv("LIARA_API_KEY"),
  base_url=os.getenv("BASE_URL"),
)

with open(os.getenv("AUDIO_FILE"), "rb") as audio_file:
  transcription = client.audio.transcriptions.create(
      model=os.getenv("STT_MODEL_NAME"),
      file=audio_file,
  )

print(transcription.text)

// dotnet add package DotNetEnv
using System.Net.Http.Headers;
using System.Text.Json;
using DotNetEnv;

Env.Load();

var baseUrl = Environment.GetEnvironmentVariable("BASE_URL")
  ?? throw new Exception("BASE_URL is not defined.");

var apiKey = Environment.GetEnvironmentVariable("LIARA_API_KEY")
  ?? throw new Exception("LIARA_API_KEY is not defined.");

var modelName = Environment.GetEnvironmentVariable("STT_MODEL_NAME")
  ?? throw new Exception("STT_MODEL_NAME is not defined.");

var audioFile = Environment.GetEnvironmentVariable("AUDIO_FILE")
  ?? throw new Exception("AUDIO_FILE is not defined.");

var audioPath = Path.GetFullPath(audioFile);

if (!File.Exists(audioPath))
{
  throw new FileNotFoundException(
      $"Audio file not found: {audioPath}"
  );
}

var extension = Path.GetExtension(audioPath).ToLowerInvariant();
var fileName = Path.GetFileName(audioPath);

var mimeType = extension switch
{
  ".mp3" => "audio/mpeg",
  ".wav" => "audio/wav",
  ".flac" => "audio/flac",
  ".m4a" => "audio/mp4",
  ".ogg" => "audio/ogg",
  ".webm" => "audio/webm",
  ".aac" => "audio/aac",
  _ => throw new Exception(
      $"Unsupported audio format: {extension}"
  )
};

Console.WriteLine($"File: {fileName}");
Console.WriteLine($"Format: {extension}");
Console.WriteLine($"MIME type: {mimeType}");
Console.WriteLine($"Size: {new FileInfo(audioPath).Length} bytes");

using var client = new HttpClient();

client.DefaultRequestHeaders.Authorization =
  new AuthenticationHeaderValue(
      "Bearer",
      apiKey
  );

using var form = new MultipartFormDataContent();

form.Add(
  new StringContent(modelName),
  "model"
);

await using var audioStream = File.OpenRead(audioPath);

using var fileContent = new StreamContent(audioStream);

fileContent.Headers.ContentType =
  new MediaTypeHeaderValue(mimeType);

form.Add(
  fileContent,
  "file",
  fileName
);

var url =
  $"{baseUrl.TrimEnd('/')}/audio/transcriptions";

var response = await client.PostAsync(
  url,
  form
);

var result = await response.Content.ReadAsStringAsync();

if (!response.IsSuccessStatusCode)
{
  Console.WriteLine($"HTTP {(int)response.StatusCode}");
  Console.WriteLine(result);

  return;
}

using var json = JsonDocument.Parse(result);

if (json.RootElement.TryGetProperty(
  "text",
  out var text
))
{
  Console.WriteLine(text.GetString());
}
else
{
  Console.WriteLine(result);
}

// go get github.com/openai/openai-go/v3 github.com/joho/godotenv

package main

import (
"context"
"fmt"
"os"
"path/filepath"
"strings"

"github.com/joho/godotenv"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)

func main() {
err := godotenv.Load()
if err != nil {
	panic("Error loading .env file")
}

baseURL := os.Getenv("BASE_URL")
apiKey := os.Getenv("LIARA_API_KEY")
modelName := os.Getenv("STT_MODEL_NAME")
audioFilePath := os.Getenv("AUDIO_FILE")

audioFile, err := os.Open(audioFilePath)
if err != nil {
	panic(err)
}
defer audioFile.Close()

fileName := filepath.Base(audioFilePath)
extension := strings.ToLower(filepath.Ext(fileName))

var mimeType string

switch extension {
case ".mp3":
	mimeType = "audio/mpeg"
case ".wav":
	mimeType = "audio/wav"
case ".flac":
	mimeType = "audio/flac"
case ".m4a":
	mimeType = "audio/mp4"
case ".ogg":
	mimeType = "audio/ogg"
case ".webm":
	mimeType = "audio/webm"
case ".aac":
	mimeType = "audio/aac"
default:
	panic("Unsupported audio format: " + extension)
}

fmt.Println("File:", fileName)
fmt.Println("MIME type:", mimeType)

client := openai.NewClient(
	option.WithAPIKey(apiKey),
	option.WithBaseURL(baseURL),
)

file := openai.File(
	audioFile,
	fileName,
	mimeType,
)

transcription, err := client.Audio.Transcriptions.New(
	context.Background(),
	openai.AudioTranscriptionNewParams{
		Model: openai.AudioModel(modelName),
		File:  file,
	},
)

if err != nil {
	panic(err)
}

fmt.Println(transcription.Text)
}

// npm install dotenv
require("dotenv").config();

async function main() {
try {
  const response = await fetch(`${process.env.BASE_URL}/rerank`, {
    method: "POST",

    headers: {
      Authorization: `Bearer ${process.env.LIARA_API_KEY}`,
      "Content-Type": "application/json",
    },

    body: JSON.stringify({
      model: process.env.RERANK_MODEL_NAME,

      query: "And who is God?",

      documents: [
        "God means love, purity, intimacy, friendship",
        "God is kind",
        "God loves us and we should love him too",
        "AI means Artificial Intelligence",
      ],

      top_n: 3,
    }),
  });

  if (!response.ok) {
    const error = await response.text();
    throw new Error(`Request failed: ${response.status} - ${error}`);
  }

  const data = await response.json();

  console.log(data);
} catch (error) {
  console.error(error);
}
}

main();

<?php

// composer require vlucas/phpdotenv
require __DIR__ . '/vendor/autoload.php';

$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
$dotenv->load();

$url = $_ENV["BASE_URL"] . "/rerank";

$payload = [
  "model" => $_ENV["RERANK_MODEL_NAME"],

  "query" => "And who is God?",

  "documents" => [
      "God means love, purity, intimacy, friendship",
      "God is kind",
      "God loves us and we should love him too",
      "AI means Artificial Intelligence",
  ],

  "top_n" => 3,
];

$ch = curl_init($url);

curl_setopt_array($ch, [
  CURLOPT_POST => true,
  CURLOPT_RETURNTRANSFER => true,

  CURLOPT_HTTPHEADER => [
      "Authorization: Bearer " . $_ENV["LIARA_API_KEY"],
      "Content-Type: application/json",
  ],

  CURLOPT_POSTFIELDS => json_encode(
      $payload,
      JSON_UNESCAPED_UNICODE
  ),
]);

$response = curl_exec($ch);

if ($response === false) {
  echo "cURL Error: " . curl_error($ch);
} else {
  echo $response;
}

curl_close($ch);

import os
import requests
from dotenv import load_dotenv

load_dotenv()

url = f"{os.getenv('BASE_URL')}/rerank"

headers = {
  "Authorization": f"Bearer {os.getenv('LIARA_API_KEY')}",
  "Content-Type": "application/json",
}

payload = {
  "model": os.getenv("RERANK_MODEL_NAME"),

  "query": "And who is God?",

  "documents": [
      "God means love, purity, intimacy, friendship",
      "God is kind",
      "God loves us and we should love him too",
      "AI means Artificial Intelligence",
  ],

  "top_n": 3,
}

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

print(response.json())

using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using DotNetEnv;

Env.Load();

var baseUrl = Environment.GetEnvironmentVariable("BASE_URL");
var apiKey = Environment.GetEnvironmentVariable("LIARA_API_KEY");
var modelName = Environment.GetEnvironmentVariable("RERANK_MODEL_NAME");

var url = $"{baseUrl}/rerank";

var payload = new
{
  model = modelName,

  query = "And who is God?",

  documents = new[]
  {
      "God means love, purity, intimacy, friendship",
      "God is kind",
      "God loves us and we should love him too",
      "AI means Artificial Intelligence"
  },

  top_n = 3
};

using var client = new HttpClient();

client.DefaultRequestHeaders.Authorization =
  new AuthenticationHeaderValue("Bearer", apiKey);

var json = JsonSerializer.Serialize(payload);

var content = new StringContent(
  json,
  Encoding.UTF8,
  "application/json"
);

var response = await client.PostAsync(url, content);

var result = await response.Content.ReadAsStringAsync();

Console.WriteLine(result);

package main

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

"github.com/joho/godotenv"
)

func main() {
err := godotenv.Load()
if err != nil {
	panic("Error loading .env file")
}

baseURL := os.Getenv("BASE_URL")
apiKey := os.Getenv("LIARA_API_KEY")
modelName := os.Getenv("RERANK_MODEL_NAME")

url := baseURL + "/rerank"

payload := map[string]any{
	"model": modelName,

	"query": "And who is God?",

	"documents": []string{
		"God means love, purity, intimacy, friendship",
		"God is kind",
		"God loves us and we should love him too",
		"AI means Artificial Intelligence",
	},

	"top_n": 3,
}

body, err := json.Marshal(payload)
if err != nil {
	panic(err)
}

req, err := http.NewRequest(
	http.MethodPost,
	url,
	bytes.NewReader(body),
)
if err != nil {
	panic(err)
}

req.Header.Set(
	"Authorization",
	"Bearer "+apiKey,
)

req.Header.Set(
	"Content-Type",
	"application/json",
)

res, err := http.DefaultClient.Do(req)
if err != nil {
	panic(err)
}
defer res.Body.Close()

data, err := io.ReadAll(res.Body)
if err != nil {
	panic(err)
}

fmt.Println(string(data))
}

curl -X POST "${BASE_URL}/rerank" \
-H "Authorization: Bearer ${LIARA_API_KEY}" \
-H "Content-Type: application/json" \
-d "{
  \"model\": \"${RERANK_MODEL_NAME}\",
  \"query\": \"And who is God?\",
  \"documents\": [
    \"God means love, purity, intimacy, friendship\",
    \"God is kind\",
    \"God loves us and we should love him too\",
    \"AI means Artificial Intelligence\"
  ],
  \"top_n\": 3
}"