Doku

SDKs

Beispiele für die verbreitetsten SDKs. Alle lesen den API-Key aus der Umgebungsvariable TOKENWERK_API_KEY; ersetzen Sie MODELL durch den Namen eines Modells.

OpenAI-Format

URL https://api.tokenwerk.ai/v1, API-Key als Authorization: Bearer.

Python

terminal 
pip install openai

main.py 
import os
from openai import OpenAI

client = OpenAI(base_url="https://api.tokenwerk.ai/v1", api_key=os.environ["TOKENWERK_API_KEY"])
r = client.chat.completions.create(
    model="MODELL",
    messages=[{"role": "user", "content": "Hello"}],
)
print(r.choices[0].message.content)

JavaScript / TypeScript

terminal 
npm install openai

main.mjs 
import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.tokenwerk.ai/v1',
  apiKey: process.env.TOKENWERK_API_KEY,
});
const r = await client.chat.completions.create({
  model: 'MODELL',
  messages: [{ role: 'user', content: 'Hello' }],
});
console.log(r.choices[0].message.content);

Go

terminal 
go get github.com/openai/openai-go/v3

main.go 
package main

import (
	"context"
	"fmt"
	"os"

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

func main() {
	client := openai.NewClient(
		option.WithBaseURL("https://api.tokenwerk.ai/v1"),
		option.WithAPIKey(os.Getenv("TOKENWERK_API_KEY")),
	)
	r, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model:    "MODELL",
		Messages: []openai.ChatCompletionMessageParamUnion{openai.UserMessage("Hello")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(r.Choices[0].Message.Content)
}

Java

build.gradle.kts 
implementation("com.openai:openai-java:4.81.0")

Main.java 
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;

public class Main {
    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.builder()
            .baseUrl("https://api.tokenwerk.ai/v1")
            .apiKey(System.getenv("TOKENWERK_API_KEY"))
            .build();
        ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
            .model("MODELL")
            .addUserMessage("Hello")
            .build();
        ChatCompletion r = client.chat().completions().create(params);
        System.out.println(r.choices().get(0).message().content().orElse(""));
    }
}

.NET

terminal 
dotnet add package OpenAI

Program.cs 
using System.ClientModel;
using OpenAI;
using OpenAI.Chat;

ChatClient client = new(
    model: "MODELL",
    credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("TOKENWERK_API_KEY")!),
    options: new OpenAIClientOptions { Endpoint = new Uri("https://api.tokenwerk.ai/v1") });

ChatCompletion r = client.CompleteChat("Hello");
Console.WriteLine(r.Content[0].Text);

Vercel AI SDK

terminal 
npm install ai @ai-sdk/openai-compatible

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

const tokenwerk = createOpenAICompatible({
  name: 'tokenwerk',
  baseURL: 'https://api.tokenwerk.ai/v1',
  apiKey: process.env.TOKENWERK_API_KEY,
});
const { text } = await generateText({
  model: tokenwerk('MODELL'),
  prompt: 'Hello',
});
console.log(text);

LangChain

terminal 
pip install -U langchain-openai

main.py 
import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="MODELL",
    base_url="https://api.tokenwerk.ai/v1",
    api_key=os.environ["TOKENWERK_API_KEY"],
)
print(llm.invoke("Hello").text)

LiteLLM

Mit dem Präfix openai/ verwendet LiteLLM das OpenAI-Format mit Ihrer URL.

terminal 
pip install litellm

main.py 
import os
import litellm

r = litellm.completion(
    model="openai/MODELL",
    api_base="https://api.tokenwerk.ai/v1",
    api_key=os.environ["TOKENWERK_API_KEY"],
    messages=[{"role": "user", "content": "Hello"}],
)
print(r.choices[0].message.content)

PHP

terminal 
composer require openai-php/client

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

$client = OpenAI::factory()
    ->withApiKey(getenv('TOKENWERK_API_KEY'))
    ->withBaseUri('https://api.tokenwerk.ai/v1')
    ->make();

$r = $client->chat()->create([
    'model' => 'MODELL',
    'messages' => [['role' => 'user', 'content' => 'Hello']],
]);
echo $r->choices[0]->message->content;

Rust

terminal 
cargo add async-openai --features chat-completion
cargo add tokio --features full

main.rs 
use async_openai::{
    Client,
    config::OpenAIConfig,
    types::chat::{ChatCompletionRequestUserMessage, CreateChatCompletionRequestArgs},
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = OpenAIConfig::new()
        .with_api_base("https://api.tokenwerk.ai/v1")
        .with_api_key(std::env::var("TOKENWERK_API_KEY")?);
    let client = Client::with_config(config);
    let request = CreateChatCompletionRequestArgs::default()
        .model("MODELL")
        .messages([ChatCompletionRequestUserMessage::from("Hello").into()])
        .build()?;
    let r = client.chat().create(request).await?;
    println!("{}", r.choices[0].message.content.clone().unwrap_or_default());
    Ok(())
}

curl

terminal 
curl https://api.tokenwerk.ai/v1/chat/completions \
  -H "Authorization: Bearer $TOKENWERK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MODELL",
    "messages": [{"role": "user", "content": "Hello"}]
  }'

Anthropic-Format

URL https://api.tokenwerk.ai (ohne /v1, das SDK hängt /v1/messages an), API-Key als x-api-key.

Anthropic Python

terminal 
pip install anthropic

main.py 
import os
import anthropic

client = anthropic.Anthropic(base_url="https://api.tokenwerk.ai", api_key=os.environ["TOKENWERK_API_KEY"])
m = client.messages.create(
    model="MODELL",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
)
print(m.content[0].text)

Anthropic TypeScript

terminal 
npm install @anthropic-ai/sdk

main.mjs 
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  baseURL: 'https://api.tokenwerk.ai',
  apiKey: process.env.TOKENWERK_API_KEY,
});
const m = await client.messages.create({
  model: 'MODELL',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Hello' }],
});
console.log(m.content[0].type === 'text' ? m.content[0].text : m.content[0]);

Anthropic curl

terminal 
curl https://api.tokenwerk.ai/v1/messages \
  -H "x-api-key: $TOKENWERK_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MODELL",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello"}]
  }'