> ## Documentation Index
> Fetch the complete documentation index at: https://docs.axioniclabs.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Integrations
> Build integrations with your trained model using Telegram, Discord, FastAPI, Node.js, LangChain, and curl via the OpenAI-compatible API.
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](/products/spectra/using-your-model).
## Applying Steering at Inference
Add steering vector fields to any request:
```python Python SDK theme={null}
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,
},
)
```
```bash curl theme={null}
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": "Describe a sunset."}],
"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:**
```bash theme={null}
pip install python-telegram-bot openai
```
**Bot code:**
```python theme={null}
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:**
```bash theme={null}
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:**
```bash theme={null}
pip install discord.py openai
```
**Bot code:**
```python theme={null}
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.
```python theme={null}
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:
```typescript theme={null}
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 {
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.
```python theme={null}
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.
```bash theme={null}
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
}'
```
## Next Steps
API reference and quick start for inference
Apply vectors, behaviors, and runtime controls
Full Mechanex SDK documentation