Integrations - axionic-docs

OpenAI-compatible API — any OpenAI SDK client works for the base chat and completion request shape by changing base_url and api_key.

Structured-output helpers from OpenAI’s own API, such as response_format, do not map directly onto Axionic’s /v1/chat/completions route today. For JSON-schema-constrained outputs, use an inline policy via extra_body or the dedicated /sampling/generate endpoint as shown in Using Your Model.

Applying Steering at Inference

Add steering vector fields to any request:

response = client.chat.completions.create(
    model="your-model-name",
    messages=[{"role": "user", "content": "Describe a sunset."}],
    extra_body={
        "steering_vector_id": "sv_abc123",
        "steering_strength": 1.0,
    },
)

Integration Examples

A Python bot that responds to Telegram messages using your trained model.Install dependencies:

pip install python-telegram-bot openai

Bot code:

import os
from telegram import Update
from telegram.ext import Application, MessageHandler, filters, ContextTypes
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["AXIONIC_API_KEY"],
    base_url="https://api.axioniclabs.ai/v1",
)

MODEL_NAME = os.environ.get("MODEL_NAME", "your-model-name")

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_message = update.message.text

    response = client.chat.completions.create(
        model=MODEL_NAME,
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": user_message},
        ],
        max_tokens=512,
    )

    await update.message.reply_text(response.choices[0].message.content)

def main():
    app = Application.builder().token(os.environ["TELEGRAM_BOT_TOKEN"]).build()
    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
    app.run_polling()

if __name__ == "__main__":
    main()

Run:

export AXIONIC_API_KEY="ax_your_key_here"
export MODEL_NAME="your-model-name"
export TELEGRAM_BOT_TOKEN="your-telegram-bot-token"
python bot.py

A Discord bot using discord.py that responds when mentioned.Install dependencies:

pip install discord.py openai

Bot code:

import os
import discord
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["AXIONIC_API_KEY"],
    base_url="https://api.axioniclabs.ai/v1",
)

MODEL_NAME = os.environ.get("MODEL_NAME", "your-model-name")

intents = discord.Intents.default()
intents.message_content = True
bot = discord.Client(intents=intents)

@bot.event
async def on_message(message):
    if message.author == bot.user:
        return

    if bot.user.mentioned_in(message):
        content = message.content.replace(f"<@{bot.user.id}>", "").strip()

        response = client.chat.completions.create(
            model=MODEL_NAME,
            messages=[
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": content},
            ],
            max_tokens=512,
        )

        await message.reply(response.choices[0].message.content)

bot.run(os.environ["DISCORD_BOT_TOKEN"])

Wrap your model behind your own API endpoint — useful for custom logic, rate limiting, or internal tools.

from fastapi import FastAPI, Request
from openai import OpenAI

app = FastAPI()
client = OpenAI(
    api_key="ax_your_key_here",
    base_url="https://api.axioniclabs.ai/v1",
)

@app.post("/ask")
async def ask(request: Request):
    body = await request.json()
    prompt = body.get("prompt", "")

    response = client.chat.completions.create(
        model="your-model-name",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=body.get("max_tokens", 256),
    )

    return {"response": response.choices[0].message.content}

Using the official OpenAI Node.js SDK:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.AXIONIC_API_KEY,
  baseURL: "https://api.axioniclabs.ai/v1",
});

async function ask(prompt: string): Promise<string> {
  const response = await client.chat.completions.create({
    model: "your-model-name",
    messages: [{ role: "user", content: prompt }],
    max_tokens: 256,
  });

  return response.choices[0].message.content ?? "";
}

Point the ChatOpenAI class at the Axionic API for standard LangChain chat-model flows such as prompts, chains, and application-side orchestration.

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="your-model-name",
    api_key="ax_your_key_here",
    base_url="https://api.axioniclabs.ai/v1",
    max_tokens=256,
)

response = llm.invoke("What tools are available?")
print(response.content)

Direct HTTP request — works from any language or platform.

curl -X POST https://api.axioniclabs.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "x-api-key: ax_your_key_here" \
  -d '{
    "model": "your-model-name",
    "messages": [
      {"role": "user", "content": "Hello, what can you do?"}
    ],
    "max_tokens": 256
  }'

​Applying Steering at Inference

​Integration Examples

​Next Steps

Applying Steering at Inference

Integration Examples

Next Steps