DEV Community: Sonam

A/B Test AI Prompts at the Edge with Telnyx Stateful Actors

Sonam — Tue, 04 Aug 2026 23:40:32 +0000

Changing a prompt is easy. Knowing whether the new prompt is actually better is the hard part.

This example builds a small prompt A/B testing API on Telnyx Edge Compute. You send one task and two prompt variants. The app runs both variants through Telnyx AI Inference, stores the experiment in a Stateful Actor, and lets users vote on which result they prefer.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/edge-prompt-ab-tester

What it does

The app gives you a tiny evaluation loop:

create an experiment
compare two model responses
vote for variant A or B
close the experiment
check aggregate stats

Routes:

POST /experiments
POST /experiments/<id>/vote
POST /experiments/<id>/close
GET /experiments
GET /experiments/<id>
GET /stats
GET /health/liveness
GET /health/readiness

Create a prompt experiment

curl -X POST https://edge-prompt-ab-tester-<id>.telnyxcompute.com/experiments \
  -H "Content-Type: application/json" \
  -d '{
    "task": "Write a one-sentence tagline for an edge compute platform.",
    "variant_a": "You are a concise marketing copywriter. Return just the tagline.",
    "variant_b": "You are a technical explainer. Return just the tagline, focus on latency."
  }'

Response:

{
  "id": "exp-msf712rs-0",
  "task": "Write a one-sentence tagline for an edge compute platform.",
  "variant_a": {
    "prompt": "You are a concise marketing copywriter. Return just the tagline.",
    "response": "Real-time compute, right where your data lives."
  },
  "variant_b": {
    "prompt": "You are a technical explainer. Return just the tagline, focus on latency.",
    "response": "Execute code milliseconds from your users to eliminate network latency."
  },
  "votes_a": 0,
  "votes_b": 0,
  "status": "open",
  "created_at": "2026-08-04T21:51:55Z"
}

Vote on a result

curl -X POST https://edge-prompt-ab-tester-<id>.telnyxcompute.com/experiments/exp-msf712rs-0/vote \
  -H "Content-Type: application/json" \
  -d '{"variant":"a"}'

Close the experiment:

curl -X POST https://edge-prompt-ab-tester-<id>.telnyxcompute.com/experiments/exp-msf712rs-0/close

Check stats:

curl https://edge-prompt-ab-tester-<id>.telnyxcompute.com/stats

Example:

{
  "total_experiments": 3,
  "open_experiments": 2,
  "closed_experiments": 1,
  "total_votes": 15,
  "leader": "variant_a",
  "leader_votes": 9
}

The AI call

The app uses:

POST /v2/ai/chat/completions

Default model:

zai-org/GLM-5.2

Each prompt variant becomes the system message. The task becomes the user message. Both variants run against the same input, which makes the comparison easier to reason about.

Why Stateful Actors?

Prompt tests need a little bit of memory.

This example uses an ABTester Stateful Actor to store:

experiments
prompt variants
model responses
vote counts
open or closed status
aggregate stats

That means the API can remember experiment state without adding a separate database just for the demo.

Run it

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/edge-prompt-ab-tester

Store your API key as an Edge Compute secret:

telnyx-edge auth api-key set <YOUR_API_KEY>
telnyx-edge secrets add TELNYX_API_KEY "KEY0123..."

Install and deploy:

npm install
telnyx-edge ship

Then use the deployed URL to create experiments and collect votes.

Production notes

Before using this pattern for real product decisions, I would add:

authentication
evaluator identity
duplicate vote prevention
randomized or blinded variants
fixed evaluation sets
scoring rubrics
prompt version history
privacy controls for sensitive tasks

But even in this small form, it is useful. Prompt changes should not be judged only by vibes. They should leave a trail of examples, votes, and outcomes.

Resources:

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/edge-prompt-ab-tester
Telnyx Edge Compute docs: https://developers.telnyx.com/docs/edge-compute
Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference
Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai
Telnyx Portal: https://portal.telnyx.com/

Build an Edge Crop Advisory API with Telnyx AI Inference

Sonam — Tue, 04 Aug 2026 20:50:37 +0000

I built this as the next step after the Edge URL Summarizer example. The URL summarizer showed a simple pattern: run an AI workflow at the edge, fetch external content when needed, summarize it, and keep useful state close to the request. This crop advisory example takes that same pattern into a more real-world workflow.

Instead of only summarizing a page, the app accepts a farmer’s field note or an agriculture advisory URL, classifies the crop issue, returns structured JSON, stores the advisory in a Stateful Actor, tracks issue/severity stats, and flags critical cases for escalation.

So the goal is not “AI gives farming advice” in a vacuum. The goal is to show how an edge-hosted AI app can turn messy field input into something operational: triage, history, stats, and a clear handoff path when a human expert needs to step in.
Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/edge-agri-crop-advisory

What it does

You send the app a crop issue description:

curl -X POST https://edge-agri-crop-advisory-<id>.telnyxcompute.com/advisory \
  -H "Content-Type: application/json" \
  -d '{"description":"Tomato leaves have holes all over them. I can see green caterpillars on the underside of the leaves."}'

It returns a structured advisory:

{
  "id": "adv-msf1zxyc-0",
  "farmer_description": "Tomato leaves have holes...",
  "source": "text",
  "crop_type": "tomato",
  "issue_type": "pest",
  "severity": "medium",
  "confidence": 0.76,
  "recommendation": "Inspect the underside of leaves and remove visible caterpillars. Consider an appropriate biological or labeled treatment if damage continues.",
  "escalate": false,
  "generated_at": "2026-08-04T19:31:04Z"
}

If the case is critical, it gets flagged:

{
  "severity": "critical",
  "escalate": true,
  "escalated_to": "agronomist-on-call"
}

Routes

The example includes:

POST /advisory - create an advisory
GET /advisories - list recent advisories
GET /advisories/<id> - get one advisory
GET /stats - see issue/severity/escalation stats
GET /health/liveness - liveness check
GET /health/readiness - readiness check

POST /advisory accepts either:

description
url

If you pass a URL, the app fetches the page, strips HTML, and uses that text as input.

The AI call

The app calls:

POST /v2/ai/chat/completions

The current code path uses:

zai-org/GLM-5.2

The prompt asks the model to return JSON only with:

crop_type
issue_type
severity
confidence
recommendation

Issue types are constrained to:

disease | pest | nutrient | water | weather | unknown

Severity is constrained to:

low | medium | high | critical

That structure makes the response easier to store, display, route, and review.

The Stateful Actor part

The app uses a CropAdvisory Stateful Actor.

It stores:

advisories by ID
total advisory count
counts by issue type
counts by severity
escalation count
recent crop types

So after a few requests, you can inspect the accumulated stats:

curl https://edge-agri-crop-advisory-<id>.telnyxcompute.com/stats

Run it

Clone the repo:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/edge-agri-crop-advisory

Set your Telnyx API key:

telnyx-edge auth api-key set <YOUR_API_KEY>
telnyx-edge secrets add TELNYX_API_KEY "KEY0123..."

Install and deploy:

npm install
telnyx-edge ship

Health check:

curl -sS --retry 30 --retry-delay 5 \
  https://edge-agri-crop-advisory-<id>.telnyxcompute.com/health/liveness

Create an advisory:

curl -X POST https://edge-agri-crop-advisory-<id>.telnyxcompute.com/advisory \
  -H "Content-Type: application/json" \
  -d '{"description":"My corn has yellow streaks on bottom leaves with dark brown spots. About 30% of plants affected."}'

Production notes

This is a triage example, not a replacement for an agronomist.

Before using this pattern in production, I would add:

authentication
farmer/account identity
region and crop stage
photo input
weather data
human review for high and critical cases
localized treatment guidance
safety warnings
SMS or webhook escalation

Still, the pattern is useful: edge function for intake, AI model for structured classification, Stateful Actor for advisory history and stats.

Resources:

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/edge-agri-crop-advisory
Stateful Actors Quick Start: https://developers.telnyx.com/docs/edge-compute/stateful-actors/quick-start
Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference
Chat Completions API: https://developers.telnyx.com/api/inference/chat-completions
Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai

Build a URL Summarizer at the Edge with Telnyx AI Inference

Sonam — Tue, 04 Aug 2026 19:06:39 +0000

I have been playing with a pattern that feels useful for small AI tools:

accept a request
call an AI model
cache the result close to where the request runs
avoid building extra infrastructure until you actually need it

This example applies that pattern to URL summarization using Telnyx Edge Compute Stateful Actors.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/edge-url-summarizer

What it builds

The app is a Node.js / TypeScript Edge Compute example.

You send it a URL:

curl -X POST https://edge-url-summarizer-<id>.telnyxcompute.com/summarize \
  -H "Content-Type: application/json" \
  -d '{"url":"https://telnyx.com/blog"}'

On the first request, it:

fetches the page
extracts text from the HTML
sends the text to Telnyx AI Inference
asks for exactly three bullet points
stores the result in Stateful Actor storage

On repeat requests for the same URL, it returns the cached summary.

API routes

The example includes:

POST /summarize - summarize a URL
GET /summarize/cached?url=... - read a cached summary
POST /summarize/refresh - invalidate a cached URL
GET /stats - view cache hit/miss stats
GET /cached - list cached URLs
GET /health/liveness - liveness check
GET /health/readiness - readiness check

Example response

{
  "url": "https://example.com/article",
  "title": "Example Article",
  "bullets": [
    "The article explains the main problem.",
    "The implementation uses an edge function and AI model.",
    "Cached results make repeat requests faster."
  ],
  "word_count": 1234,
  "generated_at": "2026-08-04T12:00:00Z",
  "cached": false
}

Call the same URL again and the response comes back with:

{
  "cached": true
}

The Telnyx AI call

The app calls:

POST /v2/ai/chat/completions

The current sample uses:

zai-org/GLM-5.2

The model is prompted to return JSON only:

{
  "bullets": ["point 1", "point 2", "point 3"]
}

That keeps the app response easy to consume from a dashboard, workflow, or internal tool.

The Stateful Actor part

The cache lives in a Telnyx Stateful Actor.

The actor stores:

summaries by URL
cache hits
cache misses
total requests
unique URL count

That means the app can remember previous summaries without adding Redis or a database just for the demo.

Run it

Clone the repo:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/edge-url-summarizer

Set your Telnyx API key:

telnyx-edge auth api-key set <YOUR_API_KEY>
telnyx-edge secrets add TELNYX_API_KEY "KEY0123..."

Install and deploy:

npm install
telnyx-edge ship

Test the deployment:

curl -sS --retry 30 --retry-delay 5 \
  https://edge-url-summarizer-<id>.telnyxcompute.com/health/liveness

Summarize a page:

curl -X POST https://edge-url-summarizer-<id>.telnyxcompute.com/summarize \
  -H "Content-Type: application/json" \
  -d '{"url":"https://telnyx.com/blog"}'

Check cache stats:

curl https://edge-url-summarizer-<id>.telnyxcompute.com/stats

What I would add before production

For a production version, I would add:

authentication
rate limiting
URL allowlists or SSRF protections
URL normalization
TTL-based cache expiration
better HTML extraction
retries and observability

But as a runnable example, this is a clean way to see Edge Compute, Stateful Actors, and Telnyx AI Inference working together.

Resources:

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/edge-url-summarizer
Stateful Actors Quick Start: https://developers.telnyx.com/docs/edge-compute/stateful-actors/quick-start
Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference
Chat Completions API: https://developers.telnyx.com/api/inference/chat-completions
Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai

Route Voicemails with Python and Telnyx AI

Sonam — Thu, 30 Jul 2026 18:18:05 +0000

I built a small Flask example that turns voicemail into a routing workflow.

Code:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/voicemail-smart-router-python

The app accepts either:

a voicemail transcript
an uploaded voicemail audio file

For audio, it transcribes the voicemail first. Then it uses Telnyx AI Inference to classify the message and decide where it should go.

Run it

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/voicemail-smart-router-python
cp .env.example .env
pip install -r requirements.txt
python app.py

Configure .env:

TELNYX_API_KEY=your_telnyx_api_key
AI_MODEL=zai-org/GLM-5.2
FALLBACK_MODEL=meta-llama/Llama-3.3-70B-Instruct
HOST=127.0.0.1

Optional Slack webhook for urgent messages:

SLACK_WEBHOOK=https://hooks.slack.com/...

Classify a transcript

curl -X POST http://localhost:5000/voicemails/transcript \
  -H "Content-Type: application/json" \
  -d '{
    "transcript": "This is an emergency. Our production system is down and we need help immediately.",
    "caller_number": "+17177247292"
  }'

Example response:

{
  "category": "urgent",
  "confidence": 1.0,
  "priority": "high",
  "reason": "The caller reports a production system outage requiring immediate attention.",
  "suggested_action": "Escalate immediately to the on-call engineering team.",
  "route": "slack",
  "routed_to": "#oncall-alerts",
  "routing_status": "delivered"
}

Process voicemail audio

curl -X POST http://localhost:5000/voicemails/process \
  -F "file=@voicemail.wav" \
  -F "caller_number=+17177247292"

For audio, the app calls:

POST /v2/ai/audio/transcriptions

using:

distil-whisper/distil-large-v2

Then it calls:

POST /v2/ai/chat/completions

to classify the transcript.

Routes included

POST /voicemails/transcript
POST /voicemails/process
GET /voicemails
GET /voicemails/<id>
GET /routes
GET /health

Production ideas

This sample uses in-memory storage and a simple routing map.

For production, I would add:

auth
durable storage
webhook ingestion from real voicemail events
retries for failed delivery
real email, ticket, and CRM integrations
review queues for low-confidence messages
audit logs
configurable routing rules
PII handling before storing transcripts

The useful pattern is not just classification. It is classification plus action. The model turns a voicemail into structured intent, and the application routes it to the right workflow.

Resources:

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/voicemail-smart-router-python
Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference
Audio Transcriptions API: https://developers.telnyx.com/api/inference/create-transcription
Chat Completions API: https://developers.telnyx.com/api/inference/chat-completions
Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai

Redact PII from Call Recordings with Python and Telnyx AI

Sonam — Wed, 29 Jul 2026 19:24:41 +0000

I put together a small Flask example that redacts PII from call transcripts and call recordings using Telnyx AI.

Code:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/call-recording-redactor-python

The app has two workflows:

submit an existing transcript
upload an audio file, transcribe it, then redact the transcript

What it redacts

The prompt asks the model to replace common PII with placeholders:

names -> [NAME]
credit cards -> [CREDIT_CARD]
SSNs / national IDs -> [SSN]
phone numbers -> [PHONE]
emails -> [EMAIL]
street addresses -> [ADDRESS]
dates of birth -> [DOB]
account numbers -> [ACCOUNT_NUMBER]

The useful part is that the response is structured JSON, not just rewritten text.

{
  "redacted_transcript": "Hi, this is [NAME] calling. My card number is [CREDIT_CARD].",
  "redactions": [
    {
      "type": "name",
      "original": "John Smith",
      "redacted": "[NAME]",
      "count": 1
    }
  ],
  "items_redacted": 2,
  "pii_types_found": ["name", "credit_card"]
}

That means your app can show the sanitized transcript while still keeping an audit-friendly redaction map.

Run it

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/call-recording-redactor-python
cp .env.example .env
pip install -r requirements.txt
python app.py

Configure .env:

TELNYX_API_KEY=your_telnyx_api_key
AI_MODEL=meta-llama/Llama-3.3-70B-Instruct
HOST=127.0.0.1

Redact a transcript

curl -X POST http://localhost:5000/redact \
  -H "Content-Type: application/json" \
  -d '{
    "transcript": "Hi, this is John Smith calling. My card number is 4532-1234-5678-9012 and my SSN is 123-45-6789."
  }'

This calls Telnyx AI Inference through:

POST /v2/ai/chat/completions

Redact an audio file

curl -X POST http://localhost:5000/redact/audio \
  -F "file=@recording.wav"

For audio, the app first calls:

POST /v2/ai/audio/transcriptions

using:

distil-whisper/distil-large-v2

Then it sends the transcript through the same PII redaction flow.

Routes included

POST /redact
POST /redact/audio
GET /redactions
GET /redactions/<id>
GET /health

Production ideas

This is a starter app, so it stores redaction jobs in memory.

For production, I would add:

auth
persistent storage
async processing for long recordings
call recording webhook ingestion
schema validation for model output
audit logs
custom PII categories
role-based access to original transcripts
audio masking if the original recording must be sanitized too

The main pattern is reusable: turn communications data into structured, safer application data before it moves deeper into your systems.

Resources:

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/call-recording-redactor-python
Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference
Audio Transcriptions API: https://developers.telnyx.com/api/inference/create-transcription
Chat Completions API: https://developers.telnyx.com/api/inference/chat-completions
Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai

Build an AI Quiz Generator in Python

Sonam — Wed, 29 Jul 2026 17:42:57 +0000

I put together a small Flask example that turns any article, blog post, documentation page, or training note into a multiple-choice quiz using Telnyx AI Inference.

Code:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/quiz-generator-python

The idea is simple: send the source text to an LLM, ask for structured JSON, and return a quiz your app can render, store, or export.

What it generates

The app returns:

a quiz title
a short description
multiple-choice questions
A/B/C/D choices
one correct answer per question
explanations for the answer key

The main endpoint is:

POST /quiz/generate

Example request:

curl -X POST http://localhost:5000/quiz/generate \
  -H "Content-Type: application/json" \
  -d '{
    "text": "The Telnyx Call Control API allows developers to programmatically control phone calls. You can answer, hangup, transfer, bridge, and record calls. The API is event-driven, meaning you receive webhooks when call events happen.",
    "num_questions": 5,
    "difficulty": "medium"
  }'

Example response shape:

{
  "id": "quiz-1750280400",
  "title": "Telnyx Call Control API Fundamentals",
  "description": "Test your understanding of the Telnyx Call Control API.",
  "difficulty": "medium",
  "questions": [
    {
      "id": 1,
      "question": "What setup is required to receive event notifications?",
      "choices": {
        "A": "Assign a number to a Call Control Application",
        "B": "Enable SMS",
        "C": "Install a softphone",
        "D": "Register with SIP"
      },
      "correct_answer": "A",
      "explanation": "You need a phone number assigned to a Call Control Application with a webhook URL."
    }
  ]
}

How it works

The app calls:

POST /v2/ai/chat/completions

The default model is:

moonshotai/Kimi-K2.6

In .env:

TELNYX_API_KEY=your_telnyx_api_key
AI_MODEL=moonshotai/Kimi-K2.6
HOST=127.0.0.1

The prompt asks the model to return JSON only, with 4 choices per question and short explanations.

Routes included

The sample includes:

POST /quiz/generate
GET /quizzes
GET /quizzes/<id>
GET /quizzes/<id>/answers
GET /health

I like the separate answer-key route because it maps nicely to real learning apps. The student view and instructor view usually need different fields.

Production ideas

The example stores quizzes in memory so the core flow is easy to see.

For production, I would add:

persistent storage
authentication
review workflows
long-document chunking
exports to JSON, CSV, or LMS formats
support for true/false or short-answer questions
stronger JSON validation

This is a starter pattern, but it is a useful one: the LLM is not just returning prose. It is generating structured app data.

Resources:

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/quiz-generator-python
Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference
Chat Completions API: https://developers.telnyx.com/api/inference/chat-completions
Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai

Build an AI Moderation Classifier in Python

Sonam — Wed, 22 Jul 2026 22:17:32 +0000

Moderation is one of those product features where "just ask an LLM" sounds tempting, but it is not always the best workflow.

Some content is obvious. Known spam, repeated abuse patterns, and common scam text should be caught quickly and consistently.

Other content needs judgment. It may be contextual, vague, sarcastic, or borderline.

I put together a Python Flask example that handles both paths with Telnyx AI Inference:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/moderation-classifier-python

The app uses a two-stage pipeline:

Embeddings pre-filter against a known-bad blocklist.
LLM moderation judgment when there is no strong blocklist match.

The flow

Before moderating content, build the blocklist index:

curl -X POST http://localhost:5000/blocklist/index

That embeds the bundled sample_blocklist.json entries through:

POST /v2/ai/openai/embeddings

Then you can classify a single piece of content:

curl -X POST http://localhost:5000/moderate \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Great product, really enjoyed using it.",
    "source": "review",
    "author_id": "user-123"
  }'

The app returns structured fields:

{
  "category": "safe",
  "confidence": 1.0,
  "flags": [],
  "blocklist_match": false,
  "recommended_action": "allow",
  "reason": "Benign positive product review with no policy violations."
}

If content matches the blocklist strongly enough, the app skips the LLM and returns the matched category directly.

For anything else, it calls:

POST /v2/ai/chat/completions

The default models are:

AI_MODEL=moonshotai/Kimi-K2.6
EMBEDDING_MODEL=thenlper/gte-large

Endpoints included

The example includes:

POST /blocklist/index
POST /moderate
POST /moderate/batch
POST /blocklist
GET /blocklist
GET /moderations
GET /moderations/<id>
GET /stats
GET /health

Batch moderation supports up to 20 items:

curl -X POST http://localhost:5000/moderate/batch \
  -H "Content-Type: application/json" \
  -d '{
    "items": [
      {"content": "Great product!", "source": "review"},
      {"content": "Buy cheap followers now!", "source": "message"}
    ]
  }'

Why this shape is useful

The important idea is separating obvious moderation cases from nuanced ones.

Known-bad patterns can be handled with embeddings similarity.

Ambiguous content can go to an LLM for classification and reasoning.

The response is structured enough to plug into product logic:

allow
flag
remove
escalate

For production, I would add persistence, audit logs, human review queues, rate limiting, and a feedback loop so reviewers can tune the blocklist and thresholds over time.

Resources:

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/moderation-classifier-python
Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference
Embeddings API: https://developers.telnyx.com/api/inference/create-embeddings
Chat Completions API: https://developers.telnyx.com/api/inference/chat-completions
Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai

Build an AI Adventure Game in Python

Sonam — Wed, 22 Jul 2026 19:14:09 +0000

Most LLM demos are one prompt and one answer.

This one is a little more fun: a text-based choose-your-own-adventure game.

The player picks a genre, names a character, reads a generated scene, and chooses option 1, 2, or 3. The app keeps track of game state while Telnyx AI Inference generates the next scene.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/adventure-game-python

What the app does

The Flask API exposes:

POST /game/start
POST /game/<id>/choose
GET /game/<id>
GET /games
GET /health

Each game tracks:

genre
player name
current scene
available choices
location
health
inventory
turn count
status

Statuses can be:

ongoing
won
lost
escaped

How it uses Telnyx AI Inference

The app calls:

POST /v2/ai/chat/completions

Default model:

AI_MODEL=moonshotai/Kimi-K2.6

The system prompt asks the model to act as a game master and return JSON only:

{
  "scene": "the scene description",
  "choices": ["choice 1", "choice 2", "choice 3"],
  "state": {
    "location": "...",
    "health": 100,
    "inventory": [],
    "turn": 1
  },
  "status": "ongoing"
}

That structure is what makes the example useful. The model writes the scene, but the app can still parse the result, store state, validate choices, and decide whether the game continues.

Run it

Clone the repo:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/adventure-game-python

Create your .env:

cp .env.example .env

Add your Telnyx API key:

TELNYX_API_KEY=your_telnyx_api_key
AI_MODEL=moonshotai/Kimi-K2.6
HOST=127.0.0.1
PORT=5000

Install and start:

pip install -r requirements.txt
python app.py

Check health:

curl http://localhost:5000/health

Start a fantasy adventure:

curl -X POST http://localhost:5000/game/start \
  -H "Content-Type: application/json" \
  -d '{
    "genre": "fantasy",
    "player_name": "Aria"
  }' | python3 -m json.tool

Choose your next move:

curl -X POST http://localhost:5000/game/game-<id>/choose \
  -H "Content-Type: application/json" \
  -d '{"choice":1}' | python3 -m json.tool

Try other genres:

curl -X POST http://localhost:5000/game/start \
  -H "Content-Type: application/json" \
  -d '{"genre":"cyberpunk","player_name":"Void"}'

Valid genres:

fantasy
sci-fi
mystery
horror
cyberpunk
post-apocalyptic

Why this is a useful pattern

The game is playful, but the app pattern is practical.

It shows how to:

keep state in your backend
pass recent history back to the model
ask for structured JSON
validate user choices
continue or end a session based on model output

That same pattern can power training simulations, support flows, onboarding tutorials, guided troubleshooting, or interactive learning tools.

The model handles the creative generation. Your app owns the rules.

Resources

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/adventure-game-python

Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai

Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference

Chat Completions API: https://developers.telnyx.com/api/inference/chat-completions

Telnyx Portal: https://portal.telnyx.com/

Build Semantic Search for Support Tickets in Python

Sonam — Mon, 20 Jul 2026 22:06:27 +0000

Keyword search is useful until users describe the same problem ten different ways.

"International SMS is failing."

"Texts to Germany are not going through."

"Messages to +49 numbers are stuck."

Those might all point to the same issue, but exact keyword matching may not connect them.

This Python example builds semantic search for support tickets using Telnyx AI Inference embeddings.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/semantic-search-python

What the app does

The Flask app lets you:

index a bundled support-ticket dataset
search tickets by meaning
add a new ticket to the index
fetch a ticket by ID
inspect index stats
check health

Routes:

POST /index
POST /search
POST /tickets
GET /tickets/<id>
GET /stats
GET /health

The app calls the Telnyx embeddings endpoint:

POST /v2/ai/openai/embeddings

Default model:

EMBEDDING_MODEL=thenlper/gte-large

How it works

For each support ticket, the app combines the subject and body:

"{subject}. {body}"

Then it:

sends those strings to the Telnyx embeddings API
stores the returned vectors in a numpy matrix
embeds the search query
calculates cosine similarity
returns the top matching tickets

That gives you meaning-based search without introducing a full vector database for the first version.

Run it

Clone the repo:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/semantic-search-python

Create your .env:

cp .env.example .env

Add your Telnyx API key:

TELNYX_API_KEY=your_telnyx_api_key
EMBEDDING_MODEL=thenlper/gte-large
HOST=127.0.0.1
PORT=5000

Install and start:

pip install -r requirements.txt
python app.py

Check the service:

curl http://localhost:5000/health

Build the index:

curl -X POST http://localhost:5000/index

Search by meaning:

curl -X POST http://localhost:5000/search \
  -H "Content-Type: application/json" \
  -d '{
    "query": "I cannot send text messages to international phone numbers",
    "top_k": 3
  }' | python3 -m json.tool

Example result:

{
  "query": "I cannot send text messages to international phone numbers",
  "model": "thenlper/gte-large",
  "total_indexed": 15,
  "results": [
    {
      "ticket_id": "TKT-1002",
      "subject": "International SMS routing issue",
      "category": "messaging",
      "priority": "high",
      "score": 0.9077
    }
  ]
}

Try more queries

curl -X POST http://localhost:5000/search \
  -H "Content-Type: application/json" \
  -d '{"query":"audio quality problems on calls","top_k":3}' | python3 -m json.tool

curl -X POST http://localhost:5000/search \
  -H "Content-Type: application/json" \
  -d '{"query":"my API key stopped working after I changed it","top_k":3}' | python3 -m json.tool

curl -X POST http://localhost:5000/search \
  -H "Content-Type: application/json" \
  -d '{"query":"phone number transfer is taking too long","top_k":3}' | python3 -m json.tool

Add a new ticket

curl -X POST http://localhost:5000/tickets \
  -H "Content-Type: application/json" \
  -d '{
    "subject": "Cannot receive faxes",
    "body": "Inbound faxes from certain senders are failing to render.",
    "category": "fax",
    "priority": "medium"
  }'

The app embeds the new ticket and appends it to the in-memory vector index.

Where this fits

This pattern is useful for:

support-ticket search
duplicate ticket detection
incident triage
internal knowledge search
agent assist tools
routing similar issues to the right team

For production, you would probably swap the in-memory numpy store for pgvector, Qdrant, Weaviate, Pinecone, Redis, or another persistent vector store. You could also combine semantic search with filters for category, priority, date, account, or product.

The core idea stays simple: Telnyx turns text into vectors, and your app decides how to rank and return the results.

Resources

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/semantic-search-python

Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai

Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference

Embeddings API: https://developers.telnyx.com/api/inference/create-embeddings

Telnyx Portal: https://portal.telnyx.com/

Build an Edge Backend for a Telnyx AI Assistant

Sonam — Thu, 16 Jul 2026 05:46:30 +0000

Voice AI demos get interesting when the assistant needs real backend context.

It is one thing to have an assistant answer a call. It is another thing to have that assistant greet the caller with dynamic context, collect information, call a backend tool, and read a confirmation back during the same phone call.

This Go example shows how to use one Telnyx Edge Compute function as the backend for a Telnyx AI Assistant.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/edge-ai-assistant-backend-go

Full guide: https://developers.telnyx.com/docs/edge-compute/guides/ai-assistant-backend

What it does

The app is a Go Edge Compute function with one public URL.

That one URL handles two AI Assistant callbacks:

dynamic variables at call start
a webhook tool call during the conversation

In the demo, the assistant is a home-services lead screener. It can resolve a company name for the greeting, then call a schedule_estimate webhook tool after collecting enough information from the caller.

Why I like this pattern

Usually, the moment an AI assistant needs application context, you need to build a webhook server.

That means hosting, deployment, secrets, request verification, and a public URL.

With Edge Compute, that backend can live close to the Telnyx communications layer. You deploy a function, store secrets, and point the assistant callbacks to the function URL.

No separate server. No Docker setup. No Kubernetes just to answer a webhook.

The important pieces

The handler does three useful things:

verifies Telnyx Ed25519 signatures
dispatches based on request body shape
returns the right JSON format for either dynamic variables or tool results

Dynamic variables must be returned under a dynamic_variables key:

{
  "dynamic_variables": {
    "company_name": "Pinecrest Home Services",
    "timeframe": "two business days"
  }
}

The webhook tool returns data the assistant can use in the live conversation:

{
  "scheduled_date": "2025-04-10",
  "scheduled_time": "10:00",
  "confirmation_number": "CONF-1715234567",
  "estimate_id": "EST-1715234567"
}

Run it

Scaffold a Go function:

telnyx-edge new-func -l go -n edge-ai-assistant-backend
cd edge-ai-assistant-backend

Fetch your Telnyx public key and store it as an Edge secret:

PUBLIC_KEY=$(curl -s -H "Authorization: Bearer $TELNYX_API_KEY" \
  https://api.telnyx.com/v2/public_key | jq -r '.data.public')

telnyx-edge secrets add TELNYX_PUBLIC_KEY "$PUBLIC_KEY"

Deploy:

telnyx-edge ship
telnyx-edge list

Then configure your AI Assistant so both the dynamic variables webhook URL and the schedule_estimate webhook tool URL point to the same Edge Compute invoke URL.

The full setup is in the guide: https://developers.telnyx.com/docs/edge-compute/guides/ai-assistant-backend

Where this could go

This example uses a scheduling flow, but the backend pattern applies to:

order status lookups
appointment booking
account verification
lead qualification
dynamic greetings
warm transfer decisions
support ticket creation

The core idea is simple: keep the assistant conversational, and put the callback logic at the edge.

Resources

Edge Compute quickstart: https://developers.telnyx.com/docs/edge-compute/quickstart

AI Assistant dynamic variables: https://developers.telnyx.com/docs/inference/ai-assistants/dynamic-variables

Webhook signing: https://developers.telnyx.com/development/api-fundamentals/webhooks/receiving-webhooks#webhook-signing

Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai

Build a Natural Language to SQL API in Python

Sonam — Wed, 15 Jul 2026 23:51:45 +0000

Most data questions start in plain English.

"Which customers spent the most?"

"How many orders are pending?"

"What products generated revenue last month?"

Someone can turn those questions into SQL, but that usually means waiting on a developer, analyst, or dashboard update.

This Python example shows how to build a small natural language to SQL API with Telnyx AI Inference.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/sql-natural-language-python

What it does

The Flask app exposes:

POST /query
POST /query/sample
POST /validate
GET /queries
GET /queries/<id>
GET /health

POST /query accepts a natural-language question, SQL dialect, and schema DDL. It returns structured JSON with the generated SQL, explanation, tables used, and metadata.

POST /query/sample uses a bundled SQLite sample dataset, so you can ask a question and see real rows come back without connecting a production database.

POST /validate dry-runs a SQL string against the sample dataset.

Why validation matters

Natural language to SQL needs guardrails.

This example asks the model for read-only SQL and then checks the generated query before execution. The validation layer rejects multiple statements, comments, and write-oriented SQL keywords.

That keeps the example focused on the useful workflow:

ask a question
include schema context
generate a query
validate the query
return structured results

The model does the language translation. The app still owns the safety checks.

Run it

Clone the examples repo:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/sql-natural-language-python

Create your .env file:

cp .env.example .env

Add your Telnyx API key:

TELNYX_API_KEY=your_telnyx_api_key
AI_MODEL=moonshotai/Kimi-K2.6
HOST=127.0.0.1

Install and start:

pip install -r requirements.txt
python app.py

Ask a question against the sample dataset:

curl -X POST http://localhost:5000/query/sample \
  -H "Content-Type: application/json" \
  -d '{"question": "Show me the top 3 customers by total order revenue"}' | python3 -m json.tool

Validate a query:

curl -X POST http://localhost:5000/validate \
  -H "Content-Type: application/json" \
  -d '{"sql": "SELECT * FROM orders WHERE total > 100"}' | python3 -m json.tool

Where this could go

This is a small API, but it maps to real internal tooling:

analytics assistants
support dashboards
sales operations tools
data warehouse query helpers
product usage exploration
internal admin tools

The useful part is the boundary. The app does not blindly trust generated SQL. It asks for structured output, validates the query, and returns JSON that another system can inspect or display.

Resources

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/sql-natural-language-python

Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai

Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference

Chat Completions API: https://developers.telnyx.com/api/inference/chat-completions

Telnyx Portal: https://portal.telnyx.com/

Build a Natural Language to SQL API in Python

Sonam — Wed, 15 Jul 2026 23:21:04 +0000

Most data questions start in plain English.

"Which customers spent the most?"

"How many orders are pending?"

"What products generated revenue last month?"

Someone can turn those questions into SQL, but that usually means waiting on a developer, analyst, or dashboard update.

This Python example shows how to build a small natural language to SQL API with Telnyx AI Inference.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/sql-natural-language-python

What it does

The Flask app exposes:

POST /query
POST /query/sample
POST /validate
GET /queries
GET /queries/<id>
GET /health

POST /query accepts a natural-language question, SQL dialect, and schema DDL. It returns structured JSON with the generated SQL, explanation, tables used, and metadata.

POST /query/sample uses a bundled SQLite sample dataset, so you can ask a question and see real rows come back without connecting a production database.

POST /validate dry-runs a SQL string against the sample dataset.

Why validation matters

Natural language to SQL needs guardrails.

This example asks the model for read-only SQL and then checks the generated query before execution. The validation layer rejects multiple statements, comments, and write-oriented SQL keywords.

That keeps the example focused on the useful workflow:

ask a question
include schema context
generate a query
validate the query
return structured results

The model does the language translation. The app still owns the safety checks.

Run it

Clone the examples repo:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/sql-natural-language-python

Create your .env file:

cp .env.example .env

Add your Telnyx API key:

TELNYX_API_KEY=your_telnyx_api_key
AI_MODEL=moonshotai/Kimi-K2.6
HOST=127.0.0.1

Install and start:

pip install -r requirements.txt
python app.py

Ask a question against the sample dataset:

curl -X POST http://localhost:5000/query/sample \
  -H "Content-Type: application/json" \
  -d '{"question": "Show me the top 3 customers by total order revenue"}' | python3 -m json.tool

Validate a query:

curl -X POST http://localhost:5000/validate \
  -H "Content-Type: application/json" \
  -d '{"sql": "SELECT * FROM orders WHERE total > 100"}' | python3 -m json.tool

Where this could go

This is a small API, but it maps to real internal tooling:

analytics assistants
support dashboards
sales operations tools
data warehouse query helpers
product usage exploration
internal admin tools

The useful part is the boundary. The app does not blindly trust generated SQL. It asks for structured output, validates the query, and returns JSON that another system can inspect or display.

Resources

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/sql-natural-language-python

Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai

Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference

Chat Completions API: https://developers.telnyx.com/api/inference/chat-completions

Telnyx Portal: https://portal.telnyx.com/

DEV Community: Sonam

A/B Test AI Prompts at the Edge with Telnyx Stateful Actors

What it does

Create a prompt experiment

Vote on a result

The AI call

Why Stateful Actors?

Run it

Production notes

Build an Edge Crop Advisory API with Telnyx AI Inference

What it does

Routes

The AI call

The Stateful Actor part

Run it

Production notes

Build a URL Summarizer at the Edge with Telnyx AI Inference

What it builds

API routes

Example response

The Telnyx AI call

The Stateful Actor part

Run it

What I would add before production

Route Voicemails with Python and Telnyx AI

Categories

Run it

Classify a transcript

Process voicemail audio

Routes included

Production ideas

Redact PII from Call Recordings with Python and Telnyx AI

What it redacts

Run it

Redact a transcript

Redact an audio file

Routes included

Production ideas

Build an AI Quiz Generator in Python

What it generates

How it works

Routes included

Production ideas

Build an AI Moderation Classifier in Python

The flow

Endpoints included

Why this shape is useful

Build an AI Adventure Game in Python

What the app does

How it uses Telnyx AI Inference

Run it

Why this is a useful pattern

Resources

Build Semantic Search for Support Tickets in Python

What the app does

How it works

Run it

Try more queries

Add a new ticket

Where this fits

Resources

Build an Edge Backend for a Telnyx AI Assistant

What it does

Why I like this pattern

The important pieces

Run it

Where this could go

Resources

Build a Natural Language to SQL API in Python

What it does

Why validation matters

Run it

Where this could go

Resources

Build a Natural Language to SQL API in Python

What it does

Why validation matters

Run it

Where this could go

Resources