SDKan

# pip install openai
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1",
)

response = client.chat.completions.create(
    model="shannon-3",
    messages=[{"role": "user", "content": "Hello, Shannon!"}],
)
print(response.choices[0].message.content)

// npm install openai
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://api.shannon-ai.com/v1",
});

const response = await client.chat.completions.create({
  model: "shannon-3",
  messages: [{ role: "user", content: "Hello, Shannon!" }],
});
console.log(response.choices[0].message.content);

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

import (
	"context"
	"fmt"

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

func main() {
	client := openai.NewClient(
		option.WithAPIKey("YOUR_API_KEY"),
		option.WithBaseURL("https://api.shannon-ai.com/v1/"),
	)

	completion, err := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
		Model: "shannon-3",
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage("Hello, Shannon!"),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(completion.Choices[0].Message.Content)
}

// Gradle: implementation("com.openai:openai-java:<version>")
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .apiKey("YOUR_API_KEY")
    .baseUrl("https://api.shannon-ai.com/v1")
    .build();

ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
    .model("shannon-3")
    .addUserMessage("Hello, Shannon!")
    .build();

ChatCompletion completion = client.chat().completions().create(params);
completion.choices().get(0).message().content().ifPresent(System.out::println);

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

ChatClient client = new(
    model: "shannon-3",
    credential: new ApiKeyCredential("YOUR_API_KEY"),
    options: new OpenAIClientOptions()
    {
        Endpoint = new Uri("https://api.shannon-ai.com/v1")
    });

ChatCompletion completion = client.CompleteChat("Hello, Shannon!");
Console.WriteLine(completion.Content[0].Text);

# pip install anthropic
import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com",
)

message = client.messages.create(
    model="shannon-1.6-lite",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Shannon!"}],
)
for block in message.content:
    if block.type == "text":
        print(block.text)

// npm install @anthropic-ai/sdk
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://api.shannon-ai.com",
});

const message = await client.messages.create({
  model: "shannon-1.6-lite",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Shannon!" }],
});
for (const block of message.content) {
  if (block.type === "text") console.log(block.text);
}

// go get github.com/anthropics/anthropic-sdk-go
package main

import (
	"context"
	"fmt"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/option"
)

func main() {
	client := anthropic.NewClient(
		option.WithAPIKey("YOUR_API_KEY"),
		option.WithBaseURL("https://api.shannon-ai.com/"),
	)

	message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
		Model:     "shannon-1.6-lite",
		MaxTokens: 1024,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Shannon!")),
		},
	})
	if err != nil {
		panic(err)
	}
	for _, block := range message.Content {
		if block.Type == "text" {
			fmt.Println(block.Text)
		}
	}
}

// Gradle: implementation("com.anthropic:anthropic-java:<version>")
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;

AnthropicClient client = AnthropicOkHttpClient.builder()
    .apiKey("YOUR_API_KEY")
    .baseUrl("https://api.shannon-ai.com")
    .build();

MessageCreateParams params = MessageCreateParams.builder()
    .model("shannon-1.6-lite")
    .maxTokens(1024L)
    .addUserMessage("Hello, Shannon!")
    .build();

Message message = client.messages().create(params);
message.content().stream()
    .flatMap(block -> block.text().stream())
    .forEach(text -> System.out.println(text.text()));

curl https://api.shannon-ai.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "shannon-3",
    "messages": [{"role": "user", "content": "Hello, Shannon!"}]
  }'

import requests

response = requests.post(
    "https://api.shannon-ai.com/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "shannon-3",
        "messages": [{"role": "user", "content": "Hello, Shannon!"}],
    },
)
response.raise_for_status()
print(response.json()["choices"][0]["message"]["content"])

const response = await fetch("https://api.shannon-ai.com/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "shannon-3",
    messages: [{ role: "user", content: "Hello, Shannon!" }],
  }),
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);

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