DEV Community: Sonam

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/

Build an AI Error Explainer in Python

Sonam — Tue, 14 Jul 2026 20:51:36 +0000

Stack traces are useful, but they are not always easy to act on quickly.

When something breaks, you usually want more than the exception name. You want to know the likely root cause, how serious it is, where to look, and what fix to try first.

This Python example turns a stack trace into structured debugging JSON using Telnyx AI Inference.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/feat/error-explainer-python/error-explainer-python

What it does

The Flask app exposes:

POST /explain
GET /analyses
GET /analyses/<id>
GET /health

POST /explain accepts a stack trace, plus optional language and runtime context:

{
  "language": "python",
  "context": "Flask production server with gunicorn",
  "stack_trace": "Traceback (most recent call last):\n  File \"app.py\", line 42..."
}

The app sends the trace to Telnyx AI Inference and asks for structured JSON:

{
  "root_cause": "The outbound HTTP call is failing because the downstream service is unreachable.",
  "severity": "high",
  "confidence": 0.91,
  "likely_culprit": "app.py:42",
  "suggested_fix": "Add timeout handling and retry logic around the request.",
  "fix_snippet": "resp = requests.post(url, timeout=15)",
  "related_errors": ["requests.exceptions.Timeout"],
  "prevention": "Set explicit timeouts for outbound HTTP calls."
}

Why this shape is useful

Plain text explanations are nice for humans. Structured output is useful for apps.

With this response shape, you could:

show severity in a dashboard
send high-severity errors to Slack
attach a suggested fix to a CI failure
store analyses for recurring incidents
build an internal debugging assistant

The example stores recent analyses in memory and lets you retrieve them by ID.

Run it

Clone the examples repo:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples
git switch feat/error-explainer-python
cd error-explainer-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

Try the health endpoint:

curl http://localhost:5000/health

Explain an error:

curl -X POST http://localhost:5000/explain \
  -H "Content-Type: application/json" \
  -d '{
    "language": "python",
    "context": "Flask production server",
    "stack_trace": "KeyError: user_id"
  }' | python3 -m json.tool

Where this could go

This is a small example, but it maps pretty cleanly to real developer workflows:

CI failure explanation
incident triage
Slack alerts
support tooling
internal platform dashboards
framework-specific debugging assistants

The useful part is not only that a model can explain an error. It is that the app gets back a predictable object it can route, store, display, or review.

Resources

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

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

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

Build an AI Changelog Generator in Python

Sonam — Fri, 10 Jul 2026 00:27:18 +0000

Writing changelogs is one of those developer tasks that sounds simple until you are staring at a messy commit history.

Some commits matter to users. Some are internal cleanup. Some are merge commits. Some are meaningful only if you already know the codebase. I built a small Python example that turns commit messages or git diffs into structured changelog JSON using Telnyx AI Inference.

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

What it does

The Flask app exposes:

POST /generate
POST /generate/from-diff
GET /changelogs
GET /changelogs/<id>
GET /health

POST /generate accepts a list of commit messages:

{
  "version": "v1.4.0",
  "repo_name": "billing-service",
  "commits": [
    "feat: add Stripe webhook retry with exponential backoff",
    "fix: correct tax calculation for EU VAT exemption",
    "docs: update API reference for invoice endpoint"
  ]
}

The app asks Telnyx AI Inference to return grouped changelog JSON with sections like:

Features
Bug Fixes
Improvements
Breaking Changes
Documentation
Other

There is also a POST /generate/from-diff endpoint if you want to summarize a git diff instead of commit messages.

Why structured output matters

For a changelog tool, plain text is useful, but structured output is more flexible.

If the response comes back as JSON, you can:

render it in a docs site
save it in a release database
post it into a PR comment
send it to Slack
open a release-note review workflow
let a human approve it before publishing

The example stores generated changelogs in memory and gives each one an ID, so you can list recent changelogs or retrieve a specific one.

Run it

Clone the examples repo:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/changelog-generator-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 run:

pip install -r requirements.txt
python app.py

Try it:

curl -X POST http://localhost:5000/generate \
  -H "Content-Type: application/json" \
  -d '{
    "version": "v1.4.0",
    "repo_name": "billing-service",
    "commits": [
      "feat: add Stripe webhook retry with exponential backoff",
      "fix: correct tax calculation for EU VAT exemption",
      "docs: update API reference for invoice endpoint"
    ]
  }' | python3 -m json.tool

Where this could go

This is a small example, but it is a pretty practical developer tooling pattern:

generate draft release notes from merged PRs
summarize changes between two tags
create changelog drafts during CI
generate per-SDK release notes
publish to docs after human approval

The Telnyx code examples repo is also agent-readable, so you can use this example as a starting point and ask a coding agent to add GitHub integration, tag comparison, a UI, or a docs publishing step.

Resources

Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai
Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference

Build a CDR Usage Analytics Dashboard in Python

Sonam — Thu, 09 Jul 2026 19:09:39 +0000

Raw Call Detail Records are useful, but they are not exactly fun to read.

If you are building with voice, messaging, or any communications workflow, CDR-style data can answer practical questions:

How many calls happened in a date range?
What did usage cost?
Which hours are busiest?
Which routes are most active?
Are short calls or failed calls increasing?

I put together a small Python example that turns Telnyx CDR data into a Flask analytics API, then uses Telnyx AI Inference to generate a short operational readout.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/cdr-usage-analytics-dashboard-python

What it exposes

The example includes these routes:

GET /cdrs
GET /analytics/summary
GET /analytics/peak-hours
GET /analytics/top-routes
GET /analytics/daily
GET /analytics/ai-insights
GET /health

The analytics routes do the normal dashboard work in Python:

total call count
total, average, median, and p95 duration
total, average, and max cost
grouped counts by direction, call type, and status
peak-hour distribution
top route breakdowns
daily call and cost totals

Then /analytics/ai-insights takes a compact summary of the metrics and sends it to Telnyx AI Inference through the chat completions API.

Why not ask the model to calculate everything?

Because the model should not be the calculator here.

For this kind of app, I like the split:

Code calculates the metrics that need to be exact.
The LLM explains the trend and suggests what to investigate next.

That way, your totals and costs stay deterministic, but your dashboard can still give users a helpful plain-English summary.

Run it

Clone the examples repo:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/cdr-usage-analytics-dashboard-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 run:

pip install -r requirements.txt
python app.py

Test it:

curl http://localhost:5000/health

Get a summary:

curl "http://localhost:5000/analytics/summary?start_date=2026-07-01&end_date=2026-07-08" | python3 -m json.tool

Ask for AI insights:

curl http://localhost:5000/analytics/ai-insights | python3 -m json.tool

Where this could go

This is intentionally small, but the pattern is useful:

add a UI for support or ops teams
store daily snapshots in a database
send weekly summaries to Slack
alert when costs spike
detect unusual short-call patterns
compare usage by campaign, customer, or region

The repo is also agent-readable, so you can point a coding agent at the example and ask it to extend the dashboard, add charts, wire in auth, or adapt the metrics to your own workflow.

Resources

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/cdr-usage-analytics-dashboard-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 Fax-to-JSON Pipeline in Python

Sonam — Wed, 08 Jul 2026 01:47:48 +0000

Fax is still part of a lot of real business workflows.

Healthcare, insurance, logistics, legal, finance, and back-office teams still receive forms, invoices, purchase orders, prescriptions, claims, and signed documents by fax. The problem is what happens after the fax arrives.

This Python example shows how to receive a Telnyx fax event and turn document text into structured JSON with Telnyx AI Inference:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/fax-to-structured-data-pipeline-python

What We Are Building

The app is a small Flask API with these routes:

POST /webhooks/fax   # receive Telnyx fax events
POST /extract        # extract structured data from document text
GET  /faxes          # list queued fax metadata
GET  /extracted      # list recent extraction results
GET  /health         # health check

The extraction route supports:

invoices
purchase orders
prescriptions
auto-detected document types

The AI call uses:

POST /v2/ai/chat/completions

Run It Locally

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/fax-to-structured-data-pipeline-python
cp .env.example .env
pip install -r requirements.txt
python app.py

Set these values in .env:

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

Try the Extraction Endpoint

You do not need to send a live fax to test the extraction path. Send document text directly:

curl -X POST http://localhost:5000/extract \
  -H "Content-Type: application/json" \
  -d '{
    "type": "invoice",
    "text": "Invoice #INV-1042 from Acme Medical Supplies dated 2026-07-01. Due 2026-07-31. Bill to North Clinic. Item: Nitrile gloves, quantity 10, unit price 12.50, total 125.00. Item: Face masks, quantity 5, unit price 20.00, total 100.00. Subtotal 225.00. Tax 18.00. Total 243.00. Payment terms Net 30."
  }' | python3 -m json.tool

The app asks the model for invoice-shaped JSON:

{
  "vendor": "Acme Medical Supplies",
  "invoice_number": "INV-1042",
  "date": "2026-07-01",
  "due_date": "2026-07-31",
  "line_items": [
    {
      "description": "Nitrile gloves",
      "quantity": 10,
      "unit_price": 12.5,
      "total": 125
    }
  ],
  "subtotal": 225,
  "tax": 18,
  "total": 243,
  "payment_terms": "Net 30"
}

Try Auto Detection

Use type: "auto" when you want the model to infer the document type:

curl -X POST http://localhost:5000/extract \
  -H "Content-Type: application/json" \
  -d '{
    "type": "auto",
    "text": "Purchase Order PO-7781. Vendor: Harbor Office Supply. Ship to: 500 Market St, San Francisco, CA. SKU CHAIR-22, ergonomic chair, quantity 12, unit price 199.00. Total 2388.00. Delivery requested 2026-07-20."
  }' | python3 -m json.tool

How the Fax Webhook Fits In

The live fax route is:

POST /webhooks/fax

The app verifies the Telnyx webhook signature before trusting the event. When it receives fax.received, it queues metadata like:

fax ID
sender
recipient
page count
media URL
status
timestamp

For local webhook testing, expose your app:

ngrok http 5000

Then set your Telnyx Fax Application webhook URL to:

https://<id>.ngrok.io/webhooks/fax

Production Notes

The demo keeps state in memory. For production, I would add:

media download from the fax media_url
OCR before extraction
persistent storage
schema validation per document type
retry handling
human review for regulated data
audit logs and retention policies
queue workers for high-volume intake

The example repo is also agent-readable. A coding agent can inspect the README, API reference, guide, environment file, and app code, then help you add OCR, storage, tests, queue workers, or stricter validation.

Resources

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/fax-to-structured-data-pipeline-python
Telnyx AI skills and toolkits: https://github.com/team-telnyx/ai
Telnyx Fax docs: https://developers.telnyx.com/docs/programmable-fax/send-a-fax-api
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/

Keep Outbound Numbers Healthy with AI

Sonam — Tue, 30 Jun 2026 23:52:18 +0000

Subtitle: Build a Python app that monitors Telnyx phone numbers, analyzes reputation risk with Telnyx AI Inference, and recommends when to keep, rotate, or retire a number.

Outbound workflows depend on number health more than most teams want to admit.

A number can look fine in inventory and still perform badly in the real world. Answer rates drop. Complaints increase. Campaign patterns get stale. A number that worked last month might need a cooldown, a review, or a replacement today.

That is the workflow behind this example:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/number-reputation-monitor-auto-rotate-python

It is a small Python Flask app that lists your Telnyx phone numbers, sends number-health context to Telnyx AI Inference, and records a recommendation: keep, rotate, or retire.

The App Shape

The app exposes three routes:

POST /scan to analyze up to 20 numbers
GET /health-report to inspect tracked number health and rotation recommendations
GET /health for app health

It uses two Telnyx APIs:

GET /v2/phone_numbers
POST /v2/ai/chat/completions

The current default model is set in .env.example:

AI_MODEL=MiniMaxAI/MiniMax-M3-MXFP8

The pattern is simple: pull number inventory, attach health metrics, ask the model for a constrained recommendation, and store the result.

What Happens During a Scan

You start the scan like this:

curl -X POST http://localhost:5000/scan \
  -H "Content-Type: application/json" \
  -d '{}'

The app calls Telnyx to list phone numbers, then analyzes up to the first 20 numbers.

For each number, it builds a small health payload. In the sample, the default metrics are intentionally simple:

{
  "calls": 0,
  "complaints": 0,
  "answer_rate": 0.5,
  "number": "+12125551234"
}

Then the app asks the model to return JSON like this:

{
  "risk_level": "warning",
  "recommendation": "rotate",
  "reasoning": "Answer rate is low and complaint activity is elevated"
}

If the recommendation is rotate, the app records it in a rotation log.

That is important: this sample does not automatically swap live numbers. It logs the recommendation. In a real outbound system, rotation should usually include policy checks, campaign state, routing rules, and human approval.

Why This Is Useful

Number reputation is not a single flag.

It is usually a collection of signals:

answer rates
complaints
opt-outs
call volume
campaign history
carrier filtering signals
recent routing behavior

A model is useful here when it is not asked to invent a decision from nothing. It is useful when it gets structured operational context and returns a constrained recommendation.

That makes the output easier to route into a dashboard, review queue, or outbound routing system.

Inspect the Health Report

After a scan, you can inspect current state:

curl http://localhost:5000/health-report

The response includes tracked numbers and recent rotation recommendations:

{
  "numbers": {
    "+12125551234": {
      "calls": 0,
      "complaints": 0,
      "answer_rate": 0.5,
      "analysis": {
        "risk_level": "warning",
        "recommendation": "rotate",
        "reasoning": "Example reason"
      }
    }
  },
  "rotations": []
}

That structure gives you a starting point for a real number-health dashboard.

The Small Detail That Matters

The prompt asks the model to return only JSON, with no prose and no markdown fences.

The app still includes a helper to strip markdown fences and parse the JSON object. I like that pattern because AI app code should be defensive. Prompts help, but validation is what keeps the output usable as application state.

What I Would Add Next

For production, I would add:

Real metrics from calls, messages, opt-outs, complaints, and campaign outcomes
Persistent storage for number history
Scheduled scans instead of manual scans
Alerts for critical numbers
Human approval before rotation or retirement
Routing rules that remove risky numbers from active campaigns
Warmup and cooldown policies
Audit logs for every recommendation and action

The repo is also structured to be agent-readable. Your coding agent can inspect the README, API reference, guide, environment file, and app code, then help extend it. You can ask it to add scheduled scans, persistent metrics, tests, dashboards, or real routing integration.

Try It

Code:
https://github.com/team-telnyx/telnyx-code-examples/tree/main/number-reputation-monitor-auto-rotate-python

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

List Phone Numbers API:
https://developers.telnyx.com/api/numbers/list-phone-numbers

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/

Turn Phone Numbers into Lead Signals

Sonam — Tue, 30 Jun 2026 22:14:22 +0000

Subtitle: Build a Python app that combines Telnyx Number Lookup with Telnyx AI Inference to qualify leads and recommend the best follow-up channel.

A lead form usually gives you just enough information to create a question.

Someone enters a name, an email address, maybe a phone number, and maybe a note about what they want. Now the app has to decide what happens next. Does this lead go to sales? Should the first touch be SMS or voice? Is the phone number even usable?

That is the workflow behind this example:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/number-lookup-lead-enrichment-python

It is a small Python Flask app that takes a phone number, enriches it with Telnyx Number Lookup, then uses Telnyx AI Inference to score the lead and recommend a follow-up channel.

The App Shape

The app exposes three routes:

POST /enrich for one phone number
POST /enrich/bulk for up to 50 phone numbers
GET /health for app health

It uses two Telnyx APIs:

GET /v2/number_lookup/{phone}
POST /v2/ai/chat/completions

The current default model is set in .env.example:

AI_MODEL=MiniMaxAI/MiniMax-M3-MXFP8

The pattern is simple: gather phone intelligence first, then use an inference model to turn that data into a lead-quality decision.

What Goes In

The request is intentionally small:

curl -X POST http://localhost:5000/enrich \
  -H "Content-Type: application/json" \
  -d '{
    "phone_number": "+12125550123"
  }'

The app looks up the number and extracts fields like carrier name, carrier type, caller name, line type, country, and validity.

Then it asks the model to return JSON like:

{
  "lead_quality": "hot",
  "reasoning": "Valid mobile number with usable carrier data",
  "is_mobile": true,
  "is_voip": false,
  "recommended_channel": "sms"
}

That response is much easier to build with than a paragraph. A product can route it, store it, show it in a CRM, or use it to kick off a workflow.

Why This Is Useful

Lead enrichment usually turns into a pile of small decisions:

Is this number valid?
Is it likely mobile?
Is it VoIP?
Is there carrier context?
Should this lead be contacted by SMS, voice, or email?
Should it go into a high-priority queue?

Number Lookup gives you the underlying phone intelligence. AI Inference lets you apply a lightweight reasoning layer over that data.

That is a nice AI app pattern because the model is not doing everything. It is operating on structured context from a real API.

The Small Detail That Matters

The app asks the model to return only JSON, with no prose and no markdown fences.

It still includes a helper to strip markdown fences and parse the JSON object. I like that because AI app code should be defensive. Prompts reduce variance, but validation is what keeps the output safe to use in an application.

The example keeps everything readable in one Flask app, which makes it easy to adapt.

What I Would Add Next

For production, I would add:

E.164 normalization before lookup
Persistent storage for enriched leads
Auth on the API endpoints
Retry handling for lookup and inference calls
CRM integration
Rate limiting for bulk enrichment
More explicit schemas for lead scoring
Human review for ambiguous high-value leads

The repo is also structured to be agent-readable. Your coding agent can inspect the README, API reference, guide, environment file, and app code, then help extend it. You can ask it to add CRM writes, tests, stricter validation, or a scheduled enrichment job.

Try It

Code:
https://github.com/team-telnyx/telnyx-code-examples/tree/main/number-lookup-lead-enrichment-python

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

Number Lookup API:
https://developers.telnyx.com/api/number-lookup/lookup

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/

Predict Churn Before Customers Leave

Sonam — Tue, 30 Jun 2026 21:48:29 +0000

Subtitle: Build a Python app with Telnyx AI Inference that turns customer activity signals into churn risk, recommended actions, and retention next steps.

Most customer churn is only surprising because the signals were scattered.

Usage dropped in one place. Support tickets went up somewhere else. A renewal date got closer. A login did not happen for two weeks. Payment issues started showing up. None of those signals alone proves a customer is leaving, but together they usually tell a story.

That is the workflow I wanted to make easier to build: take customer activity data, pass it through an inference model, and return a structured churn assessment that a product or customer success team can actually use.

The example is here:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-customer-churn-predictor-python

It is a small Flask app using Telnyx AI Inference through the chat-completions API.

The App Shape

The app exposes a few routes:

POST /predict for one customer
POST /predict/batch for up to 20 customers
GET /predictions for recent in-memory predictions
GET /health for app health

The current default model is set in .env.example:

AI_MODEL=moonshotai/Kimi-K2.6

Under the hood, the app calls:

POST https://api.telnyx.com/v2/ai/chat/completions

The prompt asks the model to behave like a customer success analyst and return JSON only. That is the important part. This is not a chatbot. It is an application endpoint that produces structured output.

What Goes In

A request can look like this:

curl -X POST http://localhost:5000/predict \
  -H "Content-Type: application/json" \
  -d '{
    "customer_id": "CUST-123",
    "call_volumes": [120, 105, 80, 55],
    "message_volumes": [450, 420, 300, 190],
    "support_tickets": 6,
    "account_age_months": 18,
    "renewal_days": 21,
    "last_login_days": 14,
    "payment_issues": 1
  }'

Those fields are deliberately simple. The point is to show the pattern, not to pretend this is a full enterprise churn model.

The model gets the trend data, support context, account age, renewal window, login recency, and payment issues. Then it returns risk, probability, risk factors, recommended actions, urgency, and revenue-at-risk context.

That response can feed a dashboard, trigger a customer success task, create a review queue, or become part of a larger retention workflow.

Why I Like This Pattern

A lot of AI product ideas start with a blank chat box.

But many useful AI apps are not blank chat boxes. They are small decision endpoints with clear inputs and clear outputs.

For churn prediction, the output shape matters:

{
  "churn_risk": "high",
  "probability": 0.82,
  "risk_factors": [
    "Usage declined over the last four months",
    "Support tickets increased",
    "Renewal date is approaching"
  ],
  "recommended_actions": [
    "Schedule an account review this week",
    "Investigate open support ticket themes"
  ],
  "urgency": "this_week"
}

That is easier to build with than a paragraph. You can sort it, store it, validate it, route it, or show it in a product.

The Small Detail That Matters

The app asks for JSON, but it still treats model output carefully.

It includes a helper that strips markdown fences and extracts the JSON object before parsing. That is the sort of thing you want in AI apps. Prompts help, but validation still matters.

The sample keeps the implementation readable so developers can inspect the whole flow in one file.

What I Would Add Next

The example uses in-memory storage because it is meant to be easy to run locally. In production, I would add:

Persistent storage for predictions
Auth on the API routes
A real customer data source
Strict schema validation
Batch processing through a queue
Alerting for high-risk accounts
Human review before customer-facing interventions

The repo is also structured to be agent-readable. That means your coding agent can inspect the README, API reference, guide, environment file, and app code, then help you extend it. You can ask it to add persistence, write tests, connect the output to a CRM, or turn the batch endpoint into a scheduled workflow.

Try It

Code:
https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-customer-churn-predictor-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 an AI Audio Translator in Python on Telnyx Inference

Sonam — Fri, 26 Jun 2026 22:14:42 +0000

A lot of AI apps are starting to mix voice, language models, and generated audio.

I built a small Python example that shows that full loop:

take an audio file
transcribe it
translate the transcript with an LLM
generate translated speech

Repo: https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-content-translator-python

What it does

The app exposes a Flask API for translating spoken content.

You send it an audio file and a target language. It returns:

the original transcript
the translated text
generated translated audio

So instead of only translating text, the example shows a practical speech-to-speech style workflow.

Why this pattern is useful

This kind of flow can be useful for apps that need multilingual voice experiences, like:

customer support tools
education apps
internal enablement content
voice agents
media localization
accessibility workflows
product tutorials in multiple languages

The important part is that each step stays understandable. Speech-to-text, translation, and text-to-speech are separate pieces, so you can debug or replace one part without rewriting the whole app.

How the example works

The app uses Telnyx APIs for the voice and AI parts of the workflow.

At a high level:

Upload source audio
Transcribe the audio
Send the transcript to an LLM for translation
Generate speech from the translated text
Return text plus audio output

That gives you a clean starting point for building your own multilingual AI workflow.

Try it

Clone the repo:

git clone https://github.com/team-telnyx/telnyx-code-examples.git cd telnyx-code-examples/ai-content-translator-python

Install dependencies and set up your environment:

pip install -r requirements.txt cp .env.example .env python app.py

Then call the translation endpoint with an audio file and target language. Check the README for the exact request shape:
https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-content-translator-python

Why I like this example

It is a useful pattern for anyone building AI apps where the interface is not just text. Text-only LLM demos are helpful, but a lot of real user experiences involve audio: people speaking, systems responding, and content moving across languages.

This example keeps the workflow small enough to understand, while still showing how speech-to-text, LLM translation, and text-to-speech can fit together in one app.
The Telnyx code examples repo is also structured to be agent-readable, so coding agents can inspect the examples, understand the API patterns, and help you extend them into fuller applications.

Resources:
Code example
Telnyx Developer Docs

Build a Simple RAG App with Telnyx AI Inference

Sonam — Fri, 26 Jun 2026 22:11:23 +0000

RAG is one of those patterns that sounds more complicated than it has to be.

At its core, retrieval-augmented generation is just:

Store some documents
Embed the user’s question
Find the most relevant docs
Send those docs to the model as context
Return an answer with sources

I built a small Python example that shows that flow end to end with Telnyx AI Inference.

Repo: https://github.com/team-telnyx/telnyx-code-examples/tree/main/build-rag-with-telnyx-inference-python

What it does

The app exposes a Flask API for asking questions against a tiny in-memory knowledge base.

You send a question like:

{ "question": "Production signup broke after rotating an API key. Logs show 401 errors. What should we check first?" }

The app

creates an embedding for the question
compares it against embeddings for the sample documents
retrieves the most relevant sources
sends those sources to a chat model
returns a grounded answer plus source titles

Why this pattern is useful

A normal LLM call only knows what is in the prompt and the model’s training data. RAG lets your app answer with your own docs, policies, product information, support notes, or internal knowledge base. That makes it useful for things like:

support assistants
internal docs search
onboarding copilots
product Q&A
troubleshooting workflows
agent tools that need source-grounded answers

How the example works

The example keeps the moving parts intentionally small.
There is an in-memory DOCUMENTS list. On the first request, the app creates embeddings for those documents and caches them. When a user asks a question, the app embeds the question, compares it to the document embeddings, and sends the best matches to the model.
The answer response includes source titles, so you can see what context the app used instead of treating the model like a black box.

Try it

Clone the repo:
git clone https://github.com/team-telnyx/telnyx-code-examples.git cd telnyx-code-examples/build-rag-with-telnyx-inference-python

Install dependencies and run the app:
pip install -r requirements.txt cp .env.example .env python app.py

Ask a question:
curl -X POST http://localhost:5000/rag/ask \ -H "Content-Type: application/json" \ -d '{ "question": "Production signup broke after rotating an API key. Logs show 401 errors. What should we check first?" }'

Why I like this example

It is deliberately small, but it gives you the core pieces of a real RAG workflow:

embeddings
retrieval
source grounding
chat completion
a clean API surface

From there, you could swap the in-memory docs for a vector database, pull content from product docs, or turn it into a support assistant.
The Telnyx code examples repo is also structured to be agent-readable, so coding agents can inspect these examples and help you extend them into fuller applications.

Resources

Code example
Telnyx AI repo with skills/toolkits
Telnyx AI Inference docs