Chat completions

curl https://api.console.larsa.larsima.com/v1/chat/completions \
  -H "Authorization: Bearer $LARSA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "larsa-general",
    "messages": [
      {"role": "user", "content": "In one paragraph, explain the difference between temperature and top_p."}
    ],
    "reasoning_effort": "none"
  }'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["LARSA_API_KEY"],
    base_url="https://api.console.larsa.larsima.com/v1",
)

response = client.chat.completions.create(
    model="larsa-general",
    messages=[
        {"role": "user", "content": "In one paragraph, explain the difference between temperature and top_p."}
    ],
    extra_body={"reasoning_effort": "none"},
)

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

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.LARSA_API_KEY,
  baseURL: "https://api.console.larsa.larsima.com/v1",
});

const response = await client.chat.completions.create({
  model: "larsa-general",
  messages: [
    {
      role: "user",
      content:
        "In one paragraph, explain the difference between temperature and top_p.",
    },
  ],
  reasoning_effort: "none",
});

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

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.LARSA_API_KEY,
  baseURL: "https://api.console.larsa.larsima.com/v1",
});

async function main(): Promise<void> {
  // reasoning_effort is a Larsa extension the SDK's published
  // types may not know about yet.
  const response = await client.chat.completions.create({
    model: "larsa-general",
    messages: [
      {
        role: "user",
        content:
          "In one paragraph, explain the difference between temperature and top_p.",
      },
    ],
    reasoning_effort: "none",
  } as any);

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

main();

package main

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

type message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type chatRequest struct {
	Model           string    `json:"model"`
	Messages        []message `json:"messages"`
	ReasoningEffort string    `json:"reasoning_effort"`
}

type chatResponse struct {
	Choices []struct {
		Message message `json:"message"`
	} `json:"choices"`
}

func main() {
	reqBody, _ := json.Marshal(chatRequest{
		Model: "larsa-general",
		Messages: []message{
			{Role: "user", Content: "In one paragraph, explain the difference between temperature and top_p."},
		},
		ReasoningEffort: "none",
	})

	req, _ := http.NewRequest("POST",
		"https://api.console.larsa.larsima.com/v1/chat/completions",
		bytes.NewReader(reqBody))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("LARSA_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

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

	body, _ := io.ReadAll(res.Body)
	var out chatResponse
	json.Unmarshal(body, &out)
	fmt.Println(out.Choices[0].Message.Content)
}

// Cargo.toml:
// [dependencies]
// reqwest = { version = "0.12", features = ["json", "blocking"] }
// serde_json = "1"

use std::env;
use serde_json::json;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("LARSA_API_KEY")?;

    let body = json!({
        "model": "larsa-general",
        "messages": [
            {"role": "user", "content": "In one paragraph, explain the difference between temperature and top_p."}
        ],
        "reasoning_effort": "none"
    });

    let client = reqwest::blocking::Client::new();
    let data: serde_json::Value = client
        .post("https://api.console.larsa.larsima.com/v1/chat/completions")
        .bearer_auth(api_key)
        .json(&body)
        .send()?
        .json()?;

    println!("{}", data["choices"][0]["message"]["content"].as_str().unwrap_or(""));
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ChatExample {
    public static void main(String[] args) throws Exception {
        String apiKey = System.getenv("LARSA_API_KEY");

        String body = "{"
                + "\"model\": \"larsa-general\","
                + "\"messages\": [{\"role\": \"user\", "
                + "\"content\": \"In one paragraph, explain the difference between temperature and top_p.\"}],"
                + "\"reasoning_effort\": \"none\""
                + "}";

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.console.larsa.larsima.com/v1/chat/completions"))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(body))
                .build();

        HttpResponse<String> response =
                client.send(request, HttpResponse.BodyHandlers.ofString());

        // A minimal HTTP example prints the raw JSON body; parse it with
        // whatever JSON library your project already uses.
        System.out.println(response.body());
    }
}

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

var apiKey = Environment.GetEnvironmentVariable("LARSA_API_KEY");

var payload = new
{
    model = "larsa-general",
    messages = new[]
    {
        new { role = "user", content = "In one paragraph, explain the difference between temperature and top_p." }
    },
    reasoning_effort = "none"
};

using var client = new HttpClient { BaseAddress = new Uri("https://api.console.larsa.larsima.com/v1/") };
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);

var body = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
var response = await client.PostAsync("chat/completions", body);
var json = await response.Content.ReadAsStringAsync();

using var doc = JsonDocument.Parse(json);
var content = doc.RootElement
    .GetProperty("choices")[0]
    .GetProperty("message")
    .GetProperty("content")
    .GetString();

Console.WriteLine(content);

<?php

$apiKey = getenv('LARSA_API_KEY');

$payload = json_encode([
    'model' => 'larsa-general',
    'messages' => [
        ['role' => 'user', 'content' => 'In one paragraph, explain the difference between temperature and top_p.'],
    ],
    'reasoning_effort' => 'none',
]);

$ch = curl_init('https://api.console.larsa.larsima.com/v1/chat/completions');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => $payload,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
    ],
    CURLOPT_RETURNTRANSFER => true,
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
echo $data['choices'][0]['message']['content'], PHP_EOL;

require "net/http"
require "json"
require "uri"

api_key = ENV.fetch("LARSA_API_KEY")

uri = URI("https://api.console.larsa.larsima.com/v1/chat/completions")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer #{api_key}"
request["Content-Type"] = "application/json"
request.body = {
  model: "larsa-general",
  messages: [
    { role: "user", content: "In one paragraph, explain the difference between temperature and top_p." },
  ],
  reasoning_effort: "none",
}.to_json

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

data = JSON.parse(response.body)
puts data["choices"][0]["message"]["content"]