ورودی‌ها (پرامپت‌ها) در هوش مصنوعی

curl <baseUrl>/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer <LIARA_API_KEY>" \
-d '{
"model": "<modelName>",
"messages": [
  {"role": "user", "content": "Hello!"}
]
}'

// npm install openai
              
const OpenAI = require('openai');

const openai = new OpenAI({
baseURL: '<baseUrl>',
apiKey: '<LIARA_API_KEY>',
});

async function main() {
const completion = await openai.chat.completions.create({
  model: '<model_name>',
  messages: [
    {
      role: 'user',
      content: 'Hello!',
    },
  ],
});

console.log(completion.choices[0].message);
}

main();

<!-- composer require openai-php/client guzzlehttp/guzzle -->

<?php

require 'vendor/autoload.php';

use OpenAI\Client;
use OpenAI\Laravel\Facades\OpenAI;
use OpenAI\Contracts\ResponseContracts\Chat\CreateResponse;

$yourApiKey = '<LIARA_API_KEY>'; 
$baseUrl = '<baseUrl>'; 
$model = '<model_name>'; 

// Create the OpenAI client
$client = \OpenAI::factory()
  ->withApiKey($yourApiKey)
  ->withBaseUri($baseUrl)
  ->make();

// Send a chat completion request
$result = $client->chat()->create([
  'model' => $model,
  'messages' => [
      ['role' => 'user', 'content' => 'I love U Bro!'],
  ],
]);

// Print the response
echo $result->choices[0]->message->content;

# pip install openai
              
from openai import OpenAI

client = OpenAI(
base_url="<baseUrl>",
api_key="<LIARA_API_KEY>",
)

completion = client.chat.completions.create(
model="<model_name>",
messages=[
  {
    "role": "user",
    "content": 'Hello!'
  }
]
)

print(completion.choices[0].message.content)

// dotnet add package OpenAI
              
using System.ClientModel;
using OpenAI;
using OpenAI.Chat;

class Program
{
  static void Main()
  {
      string apiKey = "<LIARA_API_KEY>";
      
      string baseUrl = "<baseUrl>";
      
      OpenAIClientOptions options = new OpenAIClientOptions
      {
          Endpoint = new Uri(baseUrl)
      };

      ChatClient client = new(model: "<model_name>", credential: new ApiKeyCredential(apiKey), options: options);

      ChatCompletion completion = client.CompleteChat("Hello!");

      Console.WriteLine($"[ASSISTANT]: {completion.Content[0].Text}");
  }
}

// go get github.com/openai/openai-go
// go get github.com/openai/openai-go/option
              
package main

import (
"context"
"fmt"

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

func main() {
const model = "<model_name>" 


client := openai.NewClient(
	option.WithAPIKey("<LIARA_API_KEY>"),
	option.WithBaseURL("<baseUrl>"),       
)

chatCompletion, err := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
	Messages: []openai.ChatCompletionMessageParamUnion{
		openai.UserMessage("Hello!"),          
	},
	Model: model,                                           
})
if err != nil {
	panic(err.Error())          
}

fmt.Println("Model Response:", chatCompletion.Choices[0].Message.Content)
}

// npm i @ai-sdk/openai-compatible
import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';

const { text } = await generateText({
model: createOpenAICompatible({
  baseURL: process.env.MY_BASE_URL,
  name: 'example',
  apiKey: process.env.MY_API_KEY,
}).chatModel("openai/gpt-4o-mini"),


prompt: 'hey.',

});

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

// npm i @ai-sdk/openai-compatible
import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';

async function main() {
const model = createOpenAICompatible({
  baseURL: process.env.MY_BASE_URL as string,
  name: 'example',
  apiKey: process.env.MY_API_KEY as string,
}).chatModel("openai/gpt-4o-mini");

const { text } = await generateText({
  model,


  prompt: 'hey.',

});

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

main().catch(console.error);

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

const destination = "Paris";
const lengthOfStay = 5;


const { text } = await generateText({
model: createOpenAICompatible({
  baseURL: process.env.MY_BASE_URL,
  name: 'example',
  apiKey: process.env.MY_API_KEY,
}).chatModel("openai/gpt-4o-mini"),


prompt: `I am planning a trip to ${destination} for ${lengthOfStay} days. ` +
  `Please suggest the best tourist activities for me to do.`,

});

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

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

const destination = "Paris";
const lengthOfStay = 5;

async function main() {
const model = createOpenAICompatible({
  baseURL: process.env.MY_BASE_URL as string,
  name: 'example',
  apiKey: process.env.MY_API_KEY as string,
}).chatModel("openai/gpt-4o-mini");

const { text } = await generateText({
  model,
  prompt:
    `I am planning a trip to ${destination} for ${lengthOfStay} days. ` +
    `Please suggest the best tourist activities for me to do.`,
});

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

main().catch(console.error);

// npm i @ai-sdk/openai-compatible
import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';

const destination = "Paris";
const lengthOfStay = 5;


const { text } = await generateText({
model: createOpenAICompatible({
  baseURL: process.env.MY_BASE_URL,
  name: 'example',
  apiKey: process.env.MY_API_KEY,
}).chatModel("openai/gpt-4o-mini"),

system:
  `You help planning travel itineraries. ` +
  `Respond to the users' request with a list ` +
  `of the best stops to make in their destination.`,

prompt: `I am planning a trip to ${destination} for ${lengthOfStay} days. ` +
  `Please suggest the best tourist activities for me to do.`,

});

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

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';
// import { config } from 'dotenv';
// config();

const destination = "Paris";
const lengthOfStay = 5;

async function main() {
const model = createOpenAICompatible({
  baseURL: process.env.MY_BASE_URL as string,
  name: 'example',
  apiKey: process.env.MY_API_KEY as string,
}).chatModel("openai/gpt-4o-mini");

const { text } = await generateText({
  model,

  
  system:
    `You help planning travel itineraries. ` +
    `Respond to the users' request with a list ` +
    `of the best stops to make in their destination.`,

  prompt:
    `I am planning a trip to ${destination} for ${lengthOfStay} days. ` +
    `Please suggest the best tourist activities for me to do.`,
});

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

main().catch(console.error);

curl <baseUrl>/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer <LIARA_API_KEY>" \
-d '{
"model": "<modelName>",
"messages": [
  {
          "role": "developer",
          "content": "Talk like a pirate."
  },
  {
          "role": "user",
          "content": "Are semicolons optional in JavaScript?"
  }

]
}'

// npm install openai
              
const OpenAI = require('openai');
const { config } = require('dotenv');
config();

const openai = new OpenAI({
baseURL: process.env.MY_BASE_URL,
apiKey: process.env.MY_API_KEY,
});

async function main() {
const completion = await openai.chat.completions.create({
  model: "openai/gpt-4o-mini",
  messages: [
      {
          role: "developer",
          content: "Talk like a pirate."
      },
      {
          role: "user",
          content: "Are semicolons optional in JavaScript?",
      },
  ],
});

console.log(completion.choices[0].message);
}

main();

<!-- composer require openai-php/client guzzlehttp/guzzle -->

<?php

require 'vendor/autoload.php';

use OpenAI\Client;
use OpenAI\Laravel\Facades\OpenAI;
use OpenAI\Contracts\ResponseContracts\Chat\CreateResponse;

$yourApiKey = '<LIARA_API_KEY>'; 
$baseUrl = '<baseUrl>'; 
$model = '<model_name>'; 

// Create the OpenAI client
$client = \OpenAI::factory()
  ->withApiKey($yourApiKey)
  ->withBaseUri($baseUrl)
  ->make();

// Send a chat completion request
$result = $client->chat()->create([
  'model' => $model,
  'messages' => [
      ['role' => 'developer', 'content' => 'Talk like a pirate.'],
      ['role' => 'user', 'content' => 'Are semicolons optional in JavaScript?'],
  ],
]);

// Print the response
echo $result->choices[0]->message->content;

from openai import OpenAI

client = OpenAI(
base_url="<baseUrl>",
api_key="<LIARA_API_KEY>",
)

completion = client.chat.completions.create(
model="openai/gpt-4o-mini",
messages=[
  {
      "role": "developer",
      "content": "Talk like a pirate."
  },
  {
      "role": "user",
      "content": "Are semicolons optional in JavaScript?"
  }
]
)

print(completion.choices[0].message.content)

// dotnet add package OpenAI
              
using System.ClientModel;
using OpenAI;
using OpenAI.Chat;

class Program
{
  static void Main()
  {
  
      string apiKey = "<LIARA_API_KEY>";
      string baseUrl = "<baseUrl>";  
      OpenAIClientOptions options = new OpenAIClientOptions
      {
          Endpoint = new Uri(baseUrl)
      };

      ChatClient client = new(model: "<model_name>", credential: new ApiKeyCredential(apiKey), options: options);


      ChatCompletion completion = client.CompleteChat(
      [
          // System messages represent instructions or other guidance about how the assistant should behave
          new SystemChatMessage("You are a helpful assistant that talks like a pirate."),

          // User messages represent user input, whether historical or the most recent input
          new UserChatMessage("Hi, can you help me?"),

          // Assistant messages in a request represent conversation history for responses
          new AssistantChatMessage("Arrr! Of course, me hearty! What can I do for ye?"),

          new UserChatMessage("What's the best way to train a parrot?"),
      ]);

      Console.WriteLine($"{completion.Role}: {completion.Content[0].Text}");        
  }
}

// go get github.com/openai/openai-go
// go get github.com/openai/openai-go/option
              
package main

import (
"context"
"fmt"

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

func main() {
const model = "<model_name>"


client := openai.NewClient(
	option.WithAPIKey("<LIARA_API_KEY>"),
	option.WithBaseURL("<baseUrl>"),       
)

chatCompletion, err := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
	Messages: []openai.ChatCompletionMessageParamUnion{
		openai.DeveloperMessage("Talk like a pirate!"),
		openai.UserMessage("Are semicolons optional in JavaScript?"),          
	},
	Model: model,                                           
})
if err != nil {
	panic(err.Error())          
}

fmt.Println("Model Response:", chatCompletion.Choices[0].Message.Content)
}

// npm i @ai-sdk/openai-compatible

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

const { text } = await generateText({
model: createOpenAICompatible({
  baseURL: process.env.MY_BASE_URL,
  name: 'example',
  apiKey: process.env.MY_API_KEY,
}).chatModel("openai/gpt-4o-mini"),

messages: [
  { role: 'user', content: 'Hi!' },
  { role: 'assistant', content: 'Hello, how can I help?' },
  { role: 'user', content: 'Where can I buy the best Ghormeh Sabzi in Iran?' },
],
});

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

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';
// import { config } from 'dotenv';
// config();


async function main() {
const model = createOpenAICompatible({
  baseURL: process.env.MY_BASE_URL as string,
  name: 'example',
  apiKey: process.env.MY_API_KEY as string,
}).chatModel("openai/gpt-4o-mini");

const { text } = await generateText({
  model,

  messages: [
    { role: 'user', content: 'Hi!' },
    { role: 'assistant', content: 'Hello, how can I help?' },
    { role: 'user', content: 'Where can I buy the best Ghormeh Sabzi in Iran?' },
  ],


});

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

main().catch(console.error);

curl <baseUrl>/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer <LIARA_API_KEY>" \
-d '{
"model": "<modelName>",
"messages": [
  {
    "role": "user",
    "content": [
      {
        "type": "text",
        "text": "Describe the image in detail."
      },
      {
        "type": "image_url",
        "image_url": {
          "url": "https://media.liara.ir/ai/dog.png"
        }
      }
    ]
  }

]
}'

// npm install openai
              
const OpenAI = require('openai');
// const { config } = require('dotenv');
// config();

const openai = new OpenAI({
baseURL: process.env.MY_BASE_URL,
apiKey: process.env.MY_API_KEY,
});

async function main() {
const completion = await openai.chat.completions.create({
  model: "openai/gpt-4o-mini",
  messages: [
      {
    "role": "user",
    "content": [
      {
        "type": "text",
        "text": "Describe the images in detail."
      },
      {
        "type": "image_url",
        "image_url": {"url": "https://media.liara.ir/ai/dog.png"}
      }
    ]
  }
  ],
});

console.log(completion.choices[0].message);
}

main();

<!-- composer require openai-php/client guzzlehttp/guzzle -->

<?php

require 'vendor/autoload.php';

use OpenAI\Client;
use OpenAI\Laravel\Facades\OpenAI;
use OpenAI\Contracts\ResponseContracts\Chat\CreateResponse;


$yourApiKey = '<LIARA_API_KEY>'; 
$baseUrl = '<baseUrl>'; 
$model = '<model_name>'; 

// Create the OpenAI client
$client = \OpenAI::factory()
  ->withApiKey($yourApiKey)
  ->withBaseUri($baseUrl)
  ->make();

// Send a chat completion request
$result = $client->chat()->create([
  'model' => $model,
  'messages' => [
      ['role' => 'user', 'content' => [
          [
          "type" => "text",
          "text" => "Describe the image in detail."
          ],
          [
              "type" => "image_url",
              "image_url" => ["url" => "https://media.liara.ir/ai/dog.png"]
          ]
      ]],
  ],
]);

// Print the response
echo $result->choices[0]->message->content;

from openai import OpenAI

client = OpenAI(
base_url="<baseUrl>",
api_key="<LIARA_API_KEY>",
)

completion = client.chat.completions.create(
model="openai/gpt-4o-mini",
messages= [
  {
    "role": "user",
    "content": [
      {
        "type": "text",
        "text": "Describe the image in detail."
      },
      {
        "type": "image_url",
        "image_url": {"url": "https://media.liara.ir/ai/dog.png"}
      }
    ]
  }
],
)

print(completion.choices[0].message.content)

using System.ClientModel;
using OpenAI;
using OpenAI.Chat;

string apiKey = "<LIARA_API_KEY>";
string baseUrl = "<baseUrl>";

OpenAIClientOptions options = new OpenAIClientOptions
{
  Endpoint = new Uri(baseUrl)
};

ChatClient client = new(
  model: "<model_name>",
  credential: new ApiKeyCredential(apiKey),
  options: options
);

// Use a public image URL
Uri imageUri = new Uri("https://media.liara.ir/ai/dog.png");

var messages = new List<ChatMessage>
{
  new UserChatMessage(
      ChatMessageContentPart.CreateTextPart("Describe this image."),
      ChatMessageContentPart.CreateImagePart(imageUri)
  )
};

ClientResult<ChatCompletion> result = await client.CompleteChatAsync(messages);
string response = result.Value.Content[0].Text;
Console.WriteLine(response);

// go get github.com/sashabaranov/go-openai

package main

import (
"context"
"fmt"

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

func main() {



config := openai.DefaultConfig("<LIARA_API_KEY>")
config.BaseURL = "<baseUrl>"
client := openai.NewClientWithConfig(config)


model := "openai/gpt-4o-mini" 
imageURL := "https://media.liara.ir/ai/dog.png"

req := openai.ChatCompletionRequest{
	Model: model,
	Messages: []openai.ChatCompletionMessage{
		{
			Role: openai.ChatMessageRoleUser,
			
			MultiContent: []openai.ChatMessagePart{
				{Type: openai.ChatMessagePartTypeText, Text: "Describe the image."},
				{Type: openai.ChatMessagePartTypeImageURL, ImageURL: &openai.ChatMessageImageURL{URL: imageURL}},
			},
		},
	},
}

resp, err := client.CreateChatCompletion(context.Background(), req)
if err != nil {
	panic(err)
}

fmt.Println("Model Response:", resp.Choices[0].Message.Content)
}

// npm i @ai-sdk/openai-compatible

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';
import { config } from 'dotenv';
import fs from 'fs';
config();

const { text } = await generateText({
model: createOpenAICompatible({
  baseURL: process.env.MY_BASE_URL,
  name: 'example',
  apiKey: process.env.MY_API_KEY,
}).chatModel("openai/gpt-4o-mini"),

messages: [
  {
    role: 'user',
    content: [
      { type: 'text', text: 'Describe the image in detail.' },
      {
        type: 'image',
        image: fs.readFileSync('dog.png'),
      },
    ],
  },
],
});

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

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';
import { config } from 'dotenv';
import fs from 'fs';
config();

async function main() {
const model = createOpenAICompatible({
  baseURL: process.env.MY_BASE_URL as string,
  name: 'example',
  apiKey: process.env.MY_API_KEY as string,
}).chatModel("openai/gpt-4.1");

const { text } = await generateText({
  model,

   messages: [
      {
        role: 'user',
        content: [
          { type: 'text', text: 'Describe the image in detail.' },
          {
            type: 'image',
            image: fs.readFileSync('dog.png'),
          },
        ],
      },
    ],

});

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

main().catch(console.error);

// npm install openai

import OpenAI from "openai";
import fs from "fs";

const openai = new OpenAI({
baseURL: "<baseUrl>",
apiKey: "<LIARA_API_KEY>",
});

async function main() {

// Read and base64 encode the audio file
const audioFile = fs.readFileSync("liara-song.mp3");
const audioBase64 = audioFile.toString("base64");

const completion = await openai.chat.completions.create({
  model: "google/gemini-2.5-flash", 
  messages: [
    {
      role: "user",
      content: [
        {
          type: "text",
          text: "What is the audio saying?",
        },
        {
          type: "input_audio",
          input_audio: {
            data: audioBase64,
            format: "mp3",
          },
        },
      ],
    },
  ],
});

console.log(completion.choices[0].message.content);
}

main();

<!-- composer require openai-php/client guzzlehttp/guzzle -->

<?php
require 'vendor/autoload.php';

use OpenAI\Client;

$client = OpenAI::factory()
  ->withApiKey('<LIARA_API_KEY>')
  ->withBaseUri('<baseUrl>') 
  ->make();

// Read and base64 encode the audio file
$audioData = base64_encode(file_get_contents("liara-song.mp3"));

$response = $client->chat()->create([
  "model" => "google/gemini-2.5-flash",
  "messages" => [
      [
          "role" => "user",
          "content" => [
              [
                  "type" => "text",
                  "text" => "What is the audio saying?"
              ],
              [
                  "type" => "input_audio",
                  "input_audio" => [
                      "data" => $audioData,
                      "format" => "mp3"
                  ]
              ]
          ]
      ]
  ],
]);

echo $response->choices[0]->message->content;

# pip install openai

from openai import OpenAI
import base64

client = OpenAI(
base_url="<baseUrl>",
api_key="<LIARA_API_KEY>",
)

with open("liara-song.mp3", "rb") as audio_file:
  audio_data = base64.b64encode(audio_file.read()).decode('utf-8')

completion = client.chat.completions.create(
model="google/gemini-2.5-flash",
messages=[
  {
    "role": "user",
    "content": [
      {
        "type": "text",
        "text": "What is the audio saying?"
      },
      {
        "type": "input_audio",
        "input_audio": {
          "data": audio_data,
          "format": "mp3"
        }
      }
    ]
  }
],
)

print(completion.choices[0].message.content)

// dotnet add package OpenAI

using System;
using System.IO;
using System.Threading.Tasks;
using System.ClientModel;
using OpenAI;
using OpenAI.Chat;

class Program
{
  static async Task Main()
  {
      string apiKey  = "<LIARA_API_KEY>";
      string baseUrl = "<baseUrl>";

      OpenAIClientOptions options = new OpenAIClientOptions
      {
          Endpoint = new Uri(baseUrl)
      };

      ChatClient client = new(
          model: "google/gemini-2.5-flash",
          credential: new ApiKeyCredential(apiKey),
          options: options
      );

      
      byte[] audioBytes = File.ReadAllBytes("liara-song.mp3");
      BinaryData audioData = BinaryData.FromBytes(audioBytes);

      var messages = new List<ChatMessage>
      {
          new UserChatMessage(
              ChatMessageContentPart.CreateTextPart("What is the audio saying?"),
              ChatMessageContentPart.CreateInputAudioPart(audioData, ChatInputAudioFormat.Mp3)
          )
      };

      ClientResult<ChatCompletion> result = await client.CompleteChatAsync(messages);
      string response = result.Value.Content[0].Text;
      Console.WriteLine(response);
  }
}

// go get github.com/openai/openai-go
// go get github.com/openai/openai-go/option

package main

import (
"context"
"encoding/base64"
"encoding/json"
"fmt"
"log"
"os"

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

type InputAudio struct {
Data   string `json:"data"`
Format string `json:"format"`
}

type ContentItem struct {
Type       string     `json:"type"`
Text       string     `json:"text,omitempty"`
InputAudio *InputAudio `json:"input_audio,omitempty"`
}

type Message struct {
Role    string        `json:"role"`
Content []ContentItem `json:"content"`
}

func main() {
audioPath := "liara-song.mp3"

audioBytes, err := os.ReadFile(audioPath)
if err != nil {
	log.Fatalf("Failed to read audio file: %v", err)
}

base64Audio := base64.StdEncoding.EncodeToString(audioBytes)

client := openai.NewClient(
	option.WithAPIKey("<LIARA_API_KEY>"),
	option.WithBaseURL("<BASE_URL"),
)

messages := []Message{
	{
		Role: "user",
		Content: []ContentItem{
			{Type: "text", Text: "What is the audio saying?"},
			{Type: "input_audio", InputAudio: &InputAudio{
				Data:   base64Audio,
				Format: "mp3",
			}},
		},
	},
}

params := map[string]interface{}{
	"model":    "google/gemini-2.5-flash",
	"messages": messages,
}

var result map[string]interface{}
if err := client.Post(context.Background(), "/v1/chat/completions", params, &result); err != nil {
	log.Fatalf("API request failed: %v", err)
}

if choices, ok := result["choices"].([]interface{}); ok && len(choices) > 0 {
	if msg, ok := choices[0].(map[string]interface{})["message"].(map[string]interface{}); ok {
		content, _ := json.MarshalIndent(msg["content"], "", "  ")
		fmt.Println("Model Response:", string(content))
	} else {
		fmt.Printf("Unexpected message format: %+v\n", choices[0])
	}
} else {
	fmt.Printf("No choices returned. Full response: %+v\n", result)
}
}

#!/bin/bash
# create a file named command.sh and run with `bash command.sh liara-song.mp3`

if [ $# -eq 0 ]; then
  echo "Usage: $0 <audio_file.mp3>"
  echo "Example: $0 liara-song.mp3"
  exit 1
fi

AUDIO_FILE="$1"

if [ ! -f "$AUDIO_FILE" ]; then
  echo "Error: Audio file '$AUDIO_FILE' not found"
  exit 1
fi

echo "Encoding audio file to base64..."

AUDIO_BASE64=$(base64 -w 0 "$AUDIO_FILE")

echo "Creating JSON payload..."

cat > /tmp/payload.json << EOF
{
"model": "google/gemini-2.5-flash",
"messages": [
  {
    "role": "user",
    "content": [
      {
        "type": "text",
        "text": "What is the audio saying?"
      },
      {
        "type": "input_audio",
        "input_audio": {
          "data": "$AUDIO_BASE64",
          "format": "mp3"
        }
      }
    ]
  }
]
}
EOF

echo "Sending request to API..."

curl -X POST "<baseUrl>/chat/completions" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer <LIARA_API_KEY>" \
-d @/tmp/payload.json

echo ""
echo "Cleaning up temporary files..."

rm /tmp/payload.json

echo "Done!"

import requests
import os

# import dotenv 
# dotenv.load_dotenv()

url = os.getenv("LIARA_BASE_URL")
api_key = os.getenv("LIARA_API_KEY") 
model_name = "openai/gpt-4o-mini"


headers = {
  "Authorization": f"Bearer {api_key}",
  "Content-Type": "application/json"
}

messages = [
  {
      "role": "user",
      "content": [
          {
              "type": "text",
              "text": "What are the main points in this document?"
          },
          {
              "type": "file",
              "file": {
                  "filename": "document.pdf",
                  "file_data": "https://media.liara.ir/ai/what-is-liara.pdf"
              }
          },
      ]
  }
]

payload = {
  "model": model_name,
  "messages": messages,
}

response = requests.post(url+"/chat/completions", headers=headers, json=payload)
print(response.json())

async function main() {
try {
  const apiKey = "replace with liara ai key";
  const url = "replace your base url"  + "/chat/completions"
  if (!apiKey) {
    throw new Error('API_KEY environment variable is not set');
  }

  const response = await fetch(url, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'openai/gpt-4o-mini',
      messages: [
        {
          role: 'user',
          content: [
            {
              type: 'text',
              text: 'What are the main points in this document?',
            },
            {
              type: 'file',
              file: {
                filename: 'document.pdf',
                file_data: 'https://media.liara.ir/ai/what-is-liara.pdf',
              },
            },
          ],
        },
      ],
    }),
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error('Error:', error instanceof Error ? error.message : String(error));
  process.exit(1);
}
}

main();

import requests
import base64
import os

# import dotenv 
# dotenv.load_dotenv()

def encode_pdf_to_base64(pdf_path):
  with open(pdf_path, "rb") as pdf_file:
      return base64.b64encode(pdf_file.read()).decode('utf-8')

url = os.getenv("LIARA_BASE_URL") + "/chat/completions"
api_key = os.getenv("LIARA_API_KEY") 
model_name = "openai/gpt-4o-mini"

headers = {
  "Authorization": f"Bearer {api_key}",
  "Content-Type": "application/json"
}

# Read and encode the PDF
pdf_path = "what-is-liara.pdf"
base64_pdf = encode_pdf_to_base64(pdf_path)
data_url = f"data:application/pdf;base64,{base64_pdf}"
messages = [
  {
      "role": "user",
      "content": [
          {
              "type": "text",
              "text": "What are the main points in this document?"
          },
          {
              "type": "file",
              "file": {
                  "filename": "what-is-liara.pdf",
                  "file_data": data_url
              }
          },
      ]
  }
]

payload = {
  "model": "openai/gpt-4o-mini",
  "messages": messages,
}
response = requests.post(url, headers=headers, json=payload)
print(response.json())

import fs from 'fs';

async function encodePDFToBase64(pdfPath: string): Promise<string> {
const pdfBuffer = await fs.promises.readFile(pdfPath);
const base64PDF = pdfBuffer.toString('base64');
return `data:application/pdf;base64,${base64PDF}`;
}

// Read and encode the PDF
const pdfPath = 'what-is-liara.pdf';
const base64PDF = await encodePDFToBase64(pdfPath);

const API_KEY     = "replace-with-your-api-key";
const BASE_URL    = "replace-with-your-base-url";
const MODEL       = 'openai/gpt-4o-mini'; 

const response = await fetch(BASE_URL+"/chat/completions", {
method: 'POST',
headers: {
  Authorization: `Bearer ${API_KEY}`,
  'Content-Type': 'application/json',
},
body: JSON.stringify({
  model: MODEL,
  messages: [
    {
      role: 'user',
      content: [
        {
          type: 'text',
          text: 'What are the main points in this document?',
        },
        {
          type: 'file',
          file: {
            filename: 'what-is-liara.pdf',
            file_data: base64PDF,
          },
        },
      ],
    },
  ],
}),
});

const data = await response.json();
console.log(data);

import requests
import base64
import os

# import dotenv 
# dotenv.load_dotenv()

# First, encode and send the PDF
def encode_pdf_to_base64(pdf_path):
  with open(pdf_path, "rb") as pdf_file:
      return base64.b64encode(pdf_file.read()).decode('utf-8')

url = os.getenv("LIARA_BASE_URL") + "/chat/completions"
api_key = os.getenv("LIARA_API_KEY") 
model_name = "openai/gpt-4o-mini"

headers = {
  "Authorization": f"Bearer {api_key}",
  "Content-Type": "application/json"
}

# Read and encode the PDF
pdf_path = "what-is-liara.pdf"
base64_pdf = encode_pdf_to_base64(pdf_path)
data_url = f"data:application/pdf;base64,{base64_pdf}"
messages = [
  {
      "role": "user",
      "content": [
          {
              "type": "text",
              "text": "What are the main points in this document?"
          },
          {
              "type": "file",
              "file": {
                  "filename": "what-is-liara.pdf",
                  "file_data": data_url
              }
          },
      ]
  }
]

payload = {
  "model": "openai/gpt-4o-mini",
  "messages": messages,
}
response = requests.post(url, headers=headers, json=payload)
response_data = response.json()

# Store the annotations from the response
file_annotations = None
if response_data.get("choices") and len(response_data["choices"]) > 0:
  if "annotations" in response_data["choices"][0]["message"]:
      file_annotations = response_data["choices"][0]["message"]["annotations"]
# Follow-up request using the annotations (without sending the PDF again)
if file_annotations:
  follow_up_messages = [
      {
          "role": "user",
          "content": [
              {
                  "type": "text",
                  "text": "What are the main points in this document?"
              },
              {
                  "type": "file",
                  "file": {
                      "filename": "document.pdf",
                      "file_data": data_url
                  }
              }
          ]
      },
      {
          "role": "assistant",
          "content": "The document contains information about...",
          "annotations": file_annotations
      },
      {
          "role": "user",
          "content": "Can you elaborate on the second point?"
      }
  ]
  follow_up_payload = {
      "model": "google/gemma-3-27b-it",
      "messages": follow_up_messages
  }
  follow_up_response = requests.post(url, headers=headers, json=follow_up_payload)
  print(follow_up_response.json())

import fs from 'fs';

async function encodePDFToBase64(pdfPath: string): Promise<string> {
const pdfBuffer = await fs.promises.readFile(pdfPath);
const base64PDF = pdfBuffer.toString('base64');
return `data:application/pdf;base64,${base64PDF}`;
}

async function processDocument() {

// Read and encode the PDF
const pdfPath = 'what-is-liara.pdf';
const base64PDF = await encodePDFToBase64(pdfPath);

const API_KEY     = "replace-with-your-api-key";
const BASE_URL    = "replace-with-your-base-url";
const MODEL       = 'openai/gpt-4o-mini'; 

const initialResponse = await fetch(BASE_URL+"/chat/completions", {
method: 'POST',
headers: {
  Authorization: `Bearer ${API_KEY}`,
  'Content-Type': 'application/json',
},
body: JSON.stringify({
  model: MODEL,
  messages: [
    {
      role: 'user',
      content: [
        {
          type: 'text',
          text: 'What are the main points in this document?',
        },
        {
          type: 'file',
          file: {
            filename: 'what-is-liara.pdf',
            file_data: base64PDF,
          },
        },
      ],
    },
  ],
}),
});

const initialData = await initialResponse.json();

// Store the annotations from the response
let fileAnnotations = null;
if (initialData.choices && initialData.choices.length > 0) {
  if (initialData.choices[0].message.annotations) {
    fileAnnotations = initialData.choices[0].message.annotations;
  }
}
// Follow-up request using the annotations (without sending the PDF again)
if (fileAnnotations) {
  const followUpResponse = await fetch(
    'https://openrouter.ai/api/v1/chat/completions',
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model: 'google/gemma-3-27b-it',
        messages: [
          {
            role: 'user',
            content: [
              {
                type: 'text',
                text: 'What are the main points in this document?',
              },
              {
                type: 'file',
                file: {
                  filename: 'document.pdf',
                  file_data: base64PDF,
                },
              },
            ],
          },
          {
            role: 'assistant',
            content: 'The document contains information about...',
            annotations: fileAnnotations,
          },
          {
            role: 'user',
            content: 'Can you elaborate on the second point?',
          },
        ],
      }),
    },
  );
  const followUpData = await followUpResponse.json();
  console.log(followUpData);
}
}

processDocument();