Install a client SDK

Add the Phaseo package for your language, set PHASEO_API_KEY, and send your first request. The overview lists each package’s registry and published version.

Install the package

npm install @phaseo/sdk

pnpm add @phaseo/sdk

yarn add @phaseo/sdk

You need Node.js 18 or later, and TypeScript 4.5 or later for the type definitions.

pip install phaseo

uv add phaseo

You need Python 3.10 or later. For realtime voice, install the extra: pip install "phaseo[realtime]".

go get github.com/phaseoteam/Phaseo/packages/sdk/sdk-go/v3@latest

You need Go 1.23 or later. Import the v3 module path:

import phaseo "github.com/phaseoteam/Phaseo/packages/sdk/sdk-go/v3"

dotnet add package Phaseo.Sdk

You need .NET 8 or later. The client is in the PhaseoSdk namespace.

composer require phaseo/sdk

You need PHP 8.1 or later and Composer. Composer also installs Guzzle 7. The client class is Phaseo\Sdk\Phaseo.

gem install phaseo_sdk

gem "phaseo_sdk"

You need Ruby 3.0 or later. Load it with require 'phaseo_sdk'; the client is PhaseoSdk::Phaseo.

The 3.0.0 artifact on Maven Central has the older API, without the current retry, response metadata and parameter-checking APIs. To use the current SDK, build the pinned source. You need Java 17 or later, Maven 3.8 or later, and Git.

git clone https://github.com/phaseoteam/Phaseo.git
cd Phaseo
git checkout 1ff1119f41ceb3ac2c85ed605f6e1c4beca6e011
mvn -f packages/sdk/sdk-java/pom.xml -DskipTests install

Maven installs app.phaseo:phaseo-sdk:3.0.0 in your local repository, including its Jackson dependency. Then add the dependency:

<dependency>
  <groupId>app.phaseo</groupId>
  <artifactId>phaseo-sdk</artifactId>
  <version>3.0.0</version>
</dependency>

[dependencies]
phaseo = "0.2"
serde_json = "1"

cargo add phaseo@0.2 serde_json

You need Rust 1.86 or later. The crate is pre-1.0, and its API can still change between minor versions, so pin a compatible minor version in production.

Set your API key

Create a key with phaseo keys create in the Phaseo CLI or in API Keys, then export it:

export PHASEO_API_KEY="phaseo_v1_sk_<kid>_<secret>"

$env:PHASEO_API_KEY = "phaseo_v1_sk_<kid>_<secret>"

Keep the key on your server. Don’t compile it into a desktop, mobile, browser, or other distributed client.

Send a request

import Phaseo from "@phaseo/sdk";

const client = new Phaseo({
  apiKey: process.env.PHASEO_API_KEY!,
});

const response = await client.generateText({
  model: "openai/gpt-6-astra",
  messages: [{ role: "user", content: "Hello!" }],
});

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

from phaseo import Phaseo
import os

client = Phaseo(api_key=os.environ["PHASEO_API_KEY"])

response = client.generate_text(
    {
        "model": "openai/gpt-6-astra",
        "messages": [{"role": "user", "content": "Hello!"}],
    }
)

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

client, err := phaseo.NewFromEnv() // reads PHASEO_API_KEY
if err != nil {
  panic(err)
}

chat, err := client.GenerateText(context.Background(), phaseo.ChatCompletionsRequest{
  Model:    "openai/gpt-6-astra",
  Messages: []map[string]interface{}{{"role": "user", "content": "Hello!"}},
})
if err != nil {
  panic(err)
}
fmt.Println(chat["choices"])

using PhaseoSdk;

var client = new Phaseo(); // reads PHASEO_API_KEY

var chat = await client.GenerateText(new Dictionary<string, object>
{
    ["model"] = "openai/gpt-6-astra",
    ["messages"] = new[]
    {
        new Dictionary<string, object> { ["role"] = "user", ["content"] = "Hello!" },
    },
});

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

use Phaseo\Sdk\Phaseo;

$client = new Phaseo(); // reads PHASEO_API_KEY

$chat = $client->generateText([
    'model' => 'openai/gpt-6-astra',
    'messages' => [['role' => 'user', 'content' => 'Hello!']],
]);

echo $chat['choices'][0]['message']['content'];

require 'phaseo_sdk'

client = PhaseoSdk::Phaseo.new # reads PHASEO_API_KEY

chat = client.generate_text(
  model: 'openai/gpt-6-astra',
  messages: [{ role: 'user', content: 'Hello!' }]
)

import app.phaseo.sdk.Phaseo;
import java.util.List;
import java.util.Map;

Phaseo client = new Phaseo(System.getenv("PHASEO_API_KEY"));

var chat = client.createChatCompletion(Map.of(
    "model", "openai/gpt-6-astra",
    "messages", List.of(Map.of("role", "user", "content", "Hello!"))
));
System.out.println(chat.path("choices").path(0).path("message").path("content").asText());

use phaseo::Phaseo;
use serde_json::json;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Phaseo::from_env()?;
    let response = client.chat_completions(&json!({
        "model": "openai/gpt-6-astra",
        "messages": [{ "role": "user", "content": "Hello!" }]
    }))?;

    println!("{}", response.body);
    Ok(())
}

If you don’t pass a key, the client reads PHASEO_API_KEY itself.

Point the client at another base URL

import Phaseo from "@phaseo/sdk";

const client = new Phaseo({
  apiKey: "your-api-key",
  baseUrl: "https://api.phaseo.app/v1",
  timeoutMs: 30_000,
});

from phaseo import Phaseo

client = Phaseo(
    api_key="your-api-key",
    base_url="https://api.phaseo.app/v1",
    timeout=30.0,
)

client := phaseo.New(os.Getenv("PHASEO_API_KEY"), "https://api.phaseo.app/v1")

let client = Phaseo::from_env()?.with_base_url("http://localhost:8787/v1")?;

The timeout is in milliseconds in TypeScript (timeoutMs) and in seconds in Python (timeout). In Rust, you can also set PHASEO_BASE_URL (for example http://localhost:8787/v1) for Phaseo::from_env() to pick up. Rust accepts plain HTTP only when the host is exactly localhost or a loopback IP address; remote endpoints must use HTTPS. The overview lists every option per language. Next, see Usage for one example per endpoint, or the API Reference for every field.

Introduction

Text

Image

Audio

Specialised

Admin

Point the client at another base URL

​Point the client at another base URL

Point the client at another base URL