Local Models Catalogue

Qevron serves our own models — running on our own GPU servers — through the same OpenAI-compatible interface as third-party providers (OpenAI / Anthropic / Gemini). For the client, the only thing that changes is the "model" field in the request body.

This page lists every locally-hosted model that's online right now, what it does, and how to call it — all in one table.

Quick table

Model name	Type	Notes	Endpoint (via qevron)
verinova	chat	gpt-oss-20b Q8 — reasoning OFF, fast for telephony	POST /v1/chat/completions
verinova-large	chat	Qwen3-30B-A3B-Instruct (Q8 MoE) — reasoning ON, rich/detailed answers	POST /v1/chat/completions
veriEmbedding	embedding	Multilingual embeddings (vLLM)	POST /v1/embeddings
verirerag	rerank	TEI cross-encoder; reorders search results	POST /v1/rerank
solab-stt	stt	Whisper TR/EN — speech-to-text	POST /v1/audio/transcriptions
blab-tts	tts	Piper TTS (CPU) — good for short clips	POST /v1/audio/speech
blab-fast-tr-naz	tts	Piper GPU — Turkish Naz voice	POST /v1/audio/speech
blab-fast-en-emma	tts	Piper GPU — English Emma voice	POST /v1/audio/speech
blab-stable	tts	Supertonic v3 — high quality, natural tone	POST /v1/audio/speech
spook-vision	vision	Image understanding / VQA	POST /v1/chat/completions (image input)
spook-detect	detect	Object detection — bbox list	POST /api/channel/:id/custom_test
spook-background	image	Background removal / replacement	POST /api/channel/:id/custom_test
spook-ocr	ocr	Extract text from images	POST /api/channel/:id/custom_test
spook-generate	image	Text-to-image generation	POST /v1/images/generations

Important

You don't need to know which server or port a model runs on. All requests go through the Qevron gateway (http://localhost:3001 internally, https://app.qevron.ai externally). Qevron looks at the model name and routes to the right backend channel. If a server is moved, added or removed, your code doesn't change.

Connection basics

Two environments, two base URLs:

From where?	Base URL	API key
Same-host services (calleague-platform, callekit-agents, …)	http://localhost:3001	QEVRON_API_KEY (= qevron's ADMIN_KEY)
External / SaaS clients, browser SDKs	https://app.qevron.ai	The user's own sk-... key

Auth is the same in both cases:

Authorization: Bearer <KEY>

Why a single model might live in two channels (the verinova case)

Sometimes you want two configurations of the same model. Example:

• verinova → fast, short answers for the CalleKit telephony agent (reasoning off). This channel runs on port 8903 — channel #9.
• verinova-large → detailed, "thinking" answers for the docs / chatbot side (reasoning on). This is actually a different model (Qwen3 30B), channel #143, port 8907.

The caller picks the behavior by picking the model name. There is no need to add the same model as a second channel — that just causes confusion, and Qevron's distributor will pick one of them at random, making results unstable.

Common mistake

If you add a second channel with model name verinova and base URL :8900, requests will be refused. Port 8900 belongs to vllm / veriEmbedding — there is no llama-server there. verinova is already defined as channel #9, you don't need a second one.

Chat — verinova / verinova-large

curl

curl https://app.qevron.ai/v1/chat/completions \
  -H "Authorization: Bearer sk-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "verinova",
    "messages": [
      {"role": "system", "content": "Be concise."},
      {"role": "user",   "content": "What is 1 + 1?"}
    ]
  }'

Python (openai SDK)

from openai import OpenAI

client = OpenAI(
    api_key="sk-...",
    base_url="https://app.qevron.ai/v1",
)

# Fast (telephony, short chat)
fast = client.chat.completions.create(
    model="verinova",
    messages=[{"role": "user", "content": "Write me a limerick"}],
)

# Detailed / "thinking" (reports, analysis)
deep = client.chat.completions.create(
    model="verinova-large",
    messages=[{"role": "user", "content": "Draft a PRD for a SaaS product"}],
)

Streaming

Add "stream": true — the server sends Server-Sent Events with partial chunks:

for chunk in client.chat.completions.create(
    model="verinova",
    messages=[{"role": "user", "content": "..."}],
    stream=True,
):
    print(chunk.choices[0].delta.content or "", end="", flush=True)

Embedding — veriEmbedding

curl https://app.qevron.ai/v1/embeddings \
  -H "Authorization: Bearer sk-..." \
  -H "Content-Type: application/json" \
  -d '{"model": "veriEmbedding", "input": ["merhaba dünya", "hello world"]}'

emb = client.embeddings.create(
    model="veriEmbedding",
    input=["merhaba dünya", "hello world"],
)
vectors = [item.embedding for item in emb.data]

Rerank — verirerag

curl https://app.qevron.ai/v1/rerank \
  -H "Authorization: Bearer sk-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "verirerag",
    "query": "what is qevron",
    "documents": ["Qevron is an AI gateway.", "The weather is nice today.", "Channels follow the OpenAI schema."]
  }'

The response returns indices into the documents array you sent, sorted by relevance (results[].index + relevance_score).

STT (speech-to-text) — solab-stt

curl https://app.qevron.ai/v1/audio/transcriptions \
  -H "Authorization: Bearer sk-..." \
  -F "model=solab-stt" \
  -F "file=@/path/to/audio.wav" \
  -F "language=tr"

Language hint

The language parameter is optional but recommended — it prevents Whisper from drifting to the wrong language. Use tr for Turkish, en for English.

TTS (text-to-speech) — blab-*

Same endpoint, three quality/voice options:

# Fast, CPU, short clips (notification, IVR menu)
curl https://app.qevron.ai/v1/audio/speech \
  -H "Authorization: Bearer sk-..." \
  -d '{"model": "blab-tts", "input": "Hello", "voice": "en"}' \
  -o out.wav

# GPU, Naz voice (Turkish)
curl https://app.qevron.ai/v1/audio/speech \
  -H "Authorization: Bearer sk-..." \
  -d '{"model": "blab-fast-tr-naz", "input": "Tanıştığımıza memnun oldum"}' \
  -o naz.wav

# Highest quality, natural tone (long-form, product demo)
curl https://app.qevron.ai/v1/audio/speech \
  -H "Authorization: Bearer sk-..." \
  -d '{"model": "blab-stable", "input": "Qevron serves your own models through one API."}' \
  -o stable.wav

Which one should I pick?

• blab-tts — latency-critical, content is short (notification, IVR).
• blab-fast-* — real-time phone conversation; fixed voice character (Naz/Emma).
• blab-stable — when quality matters (training video, product launch, podcast prototype).

Vision — spook-vision

Uses OpenAI's image-input format. Accepts URL or base64 data URLs.

resp = client.chat.completions.create(
    model="spook-vision",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What's in this image?"},
            {"type": "image_url", "image_url": {"url": "https://.../photo.jpg"}},
        ],
    }],
)

Image generation — spook-generate

curl https://app.qevron.ai/v1/images/generations \
  -H "Authorization: Bearer sk-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "spook-generate",
    "prompt": "Bosphorus at sunset, cinematic lighting",
    "size": "1024x1024"
  }'

Utility models — spook-detect / -ocr / -background

These three don't fit the pure OpenAI schema, so they're called via the admin custom_test endpoint:

curl https://app.qevron.ai/api/channel/85/custom_test \
  -H "Authorization: Bearer sk-..." \
  -H "Content-Type: application/json" \
  -d '{"model": "spook-detect", "image": "data:image/jpeg;base64,..."}'

Channel IDs: spook-detect=85, spook-background=86, spook-ocr=87. (You can also try them interactively from the Channels page in the admin UI via the "Test" button.)

Calleague-platform side

Calleague projects connect to Qevron through two ENV vars:

# .env
QEVRON_URL=http://localhost:3001          # If you're on the same host
QEVRON_API_KEY=<qevron ADMIN_KEY>         # qevron's .env ADMIN_KEY

In Pro / Plus flows, the [...path].ts self-host handler reads these and points the OpenAI SDK at Qevron — you only need to change the model name in code.

For callekit-agents:

QEVRON_INTERNAL_URL=http://localhost:3001
QEVRON_API_KEY=<same>

Troubleshooting

"connection refused"

In 99% of cases the base URL is pointing at the wrong port. The correct port is already wired up on the qevron side — you should not be setting ports manually. In the Qevron admin SPA:

1. Go to /channel
2. Find the model
3. Hit the "Test" button — a 200 OK means the endpoint is healthy

If it still fails, look at /cluster/assignments and check the Actual column for that runtime:

• active → the service is running; the problem is elsewhere (channel base_url, network, …)
• inactive / failed → the service is down; use Start on the right

Response is too slow

• Are you streaming? ("stream": true)
• verinova-large is naturally ~3-5× slower than verinova (30B vs 20B + reasoning on).
• Cap output for long contexts; max_tokens: 256-512 is a sane ceiling for verinova.

"model not found"

The "model" value in the request body must match the table above. Typical mistakes: Verinova (capitalized), verinova_large (underscore instead of dash), the old name gpt-oss-20b. Live list of valid models:

curl https://app.qevron.ai/v1/models -H "Authorization: Bearer sk-..."

See also

• API Overview — full reference for every endpoint
• Authentication — key generation and quotas
• First Chatbot — end-to-end example
• RAG: Embedding + Rerank — veriEmbedding + verirerag together