Is this the same as your AI services?

This page is the technology: Python as the runtime for APIs and AI workloads. Generative AI, custom LLMs, vision, NLP, and automation are the service lines that use it. We link those when the engagement is a full AI product.

Do you train models or integrate them?

Both, depending on the problem. Many products need retrieval, prompt and tool design, and evaluation around a hosted model. Custom training is scoped when your data and the task justify it.

How does Python talk to the Next.js or Node app?

Through an HTTP or queue boundary. The web app does not import Python. Types or an OpenAPI spec keep the contract visible to the TypeScript side.

How do you judge whether an AI feature is ready?

With an evaluation set: representative questions, expected sources or outcomes, and a human review of failures. We do not ship on a single happy-path demo.

Where do embeddings and documents live?

Vectors and chunks sit in Postgres extensions, a dedicated vector store, or object storage plus an index — chosen from query volume and ops preference. App truth stays in PostgreSQL.

Can you add AI into an existing product?

Yes. We usually expose a FastAPI (or similar) service behind the product API so the Next.js or Node app stays the customer-facing surface.

How do you control LLM cost?

Per-feature token budgets, caching, model tiering, and dashboards. Cost is reviewed with quality — not after the bill surprises anyone.

Do you support on-prem or private models?

When data residency requires it, we serve open models in your VPC or dedicated GPU capacity. Hosted APIs remain an option when policy allows.

Python & applied AI

Python & AI

Python services that ship.

Zupitrix uses Python for APIs, data pipelines, and AI features that have to live next to the rest of the product. FastAPI services, retrieval, and evaluation sit behind the same auth and observability as any other backend.

Start Project Follow the signal

Python

FastAPI

PostgreSQL

Pydantic

OpenAI

PyTorch

api/rag.pyFastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Ask(BaseModel):
  query: str
  tenant_id: str

@app.post("/v1/ask")
async def ask(body: Ask):
  hits = retrieve(body.query, body.tenant_id)
  answer = generate(body.query, hits)
  return {
    "answer": answer,
    "citations": [h.id for h in hits],
  }

Delivery surface

Four checks every Python AI feature has to clear before it reaches users.

APIPython services with contracts

OpenAPI + auth on every route

@app.post("/v1/ask")

RAGGrounded answers

Retrieve first · cite sources

hits = retrieve(query)

EvalQuality before launch

Fixed review set gates release

assert scorecard.pass

OpsSame deploy path as the app

Container · traces · rollback

docker run · ready

Practice

Models inside products

Python services for APIs, data jobs, and AI features with evaluation — not notebook demos.

A service, not a notebook

API · tests · container

The feature runs as an API or a job with tests, config, and a container. Notebooks stay for exploration. We document the approach, name owners, and attach acceptance checks so “A service, not a notebook” is reviewable in demos and durable after handoff.

deploy = service, not .ipynb

Grounded generation

Retrieve · cite · answer

When the product answers from your content, retrieval and citations come first. The model does not invent the source of truth. We document the approach, name owners, and attach acceptance checks so “Grounded generation” is reviewable in demos and durable after handoff.

ground(query) before generate()

Evaluation as a release check

Scorecard before ship

A fixed set of cases runs before a prompt, model, or index change reaches users. We document the approach, name owners, and attach acceptance checks so “Evaluation as a release check” is reviewable in demos and durable after handoff.

assert eval_set.passes()

Data jobs with owners

Schedule · alert · re-run

Pipelines that feed search or features have schedules, failure alerts, and a place to re-run them. We document the approach, name owners, and attach acceptance checks so “Data jobs with owners” is reviewable in demos and durable after handoff.

pipeline.owned_by = team

Build

What we productize

Python APIs

FastAPI services for domain logic, document processing, or model inference behind your auth. We document the approach, name owners, and attach acceptance checks so “Python APIs” is reviewable in demos and durable after handoff.

Applied AI features

Search, assistants, classification, and extraction wired into the product UI. We document the approach, name owners, and attach acceptance checks so “Applied AI features” is reviewable in demos and durable after handoff.

Data and indexing jobs

Ingestion and embedding pipelines that keep retrieval current. We document the approach, name owners, and attach acceptance checks so “Data and indexing jobs” is reviewable in demos and durable after handoff.

Flow

Evaluate before you launch

01
Job
Define the user outcome and the data that is allowed. Exit criteria and owners are written down before the next step starts.
02
Baseline
Measure a simple approach before adding model complexity. Exit criteria and owners are written down before the next step starts.
03
Service
Put the path behind an API the product can call. Exit criteria and owners are written down before the next step starts.
04
Evaluate
Gate releases on a review set and production traces. Exit criteria and owners are written down before the next step starts.
05
Harden
Validate budgets, failure modes, observability, and rollback before traffic. Exit criteria and owners are written down before the next step starts.
06
Handoff
Runbooks, access, and training so the client team can operate without us. Exit criteria and owners are written down before the next step starts.

Stack & services

What we run it on

FastAPI services, model adapters, and data stores — paired with the service lines that usually buy this work.

Stack

Runtime

Python
FastAPI
Pydantic
Docker

AI layer

OpenAI / open models
LangChain
PyTorch
Hugging Face

Data

PostgreSQL

from fastapi import FastAPI
app = FastAPI(title="zupitrix-ai")

Services

Productscope = full_ai_product
AI Solutions
End-to-end AI products — discovery, architecture, eval, and the services that run them.
Embedfeature = llm_in_app
Generative AI Integration
LLM features inside an existing app: prompts, tools, caching, and cost controls.
Conversechannel = chat + rag
NLP & Chatbots
Assistants and chat with retrieval, tone controls, and escalation to humans.

Outcomes

What we optimize for

Product and engineering goals we keep visible from the first slice through handoff — so velocity never quietly trades away quality.

EvalRelease gate for quality

APIService, not notebook

RAGGrounded answers

TraceProduction observability

CiteSource-linked outputs

HITLEscalation paths

At a glance

Delivery facts

Typical timelines, coverage, and operating constraints we set expectations against before the build surface expands.

Topic	Value	Note
First useful pilot	3–6 weeks	With eval gate. Tracked against Python & AI delivery milestones.
Serving default	FastAPI	Containerized. Tracked against Python & AI delivery milestones.
Grounding	RAG-first	For private data. Tracked against Python & AI delivery milestones.
UI hosts	Next/Node	Clean HTTP boundary. Tracked against Python & AI delivery milestones.
Release rule	Eval pass	Or no ship. Tracked against Python & AI delivery milestones.
Ops	Traced	Feedback looped. Tracked against Python & AI delivery milestones.

Ecosystem

Technologies that sit beside it

Real stack partners we wire into delivery with clear roles — not decorative logos on a slide.

Python

Server runtime for APIs, jobs, and SSR hosts.

FastAPI

API layer — integrated deliberately into delivery with FastAPI.

PyTorch

Custom models — integrated deliberately into delivery with PyTorch.

TensorFlow

Training — integrated deliberately into delivery with TensorFlow.

OpenAI

Hosted LLMs — integrated deliberately into delivery with OpenAI.

Hugging Face

Model hub — integrated deliberately into delivery with Hugging Face.

LangChain

Orchestration — integrated deliberately into delivery with LangChain.

PostgreSQL

App data — integrated deliberately into delivery with PostgreSQL.

Docker

Services — integrated deliberately into delivery with Docker.

Redis

Job queues — integrated deliberately into delivery with Redis.

AWS

GPU / storage — integrated deliberately into delivery with AWS.

Pandas

Data prep — integrated deliberately into delivery with Pandas.

Integrations

Systems we commonly connect

CMS, identity, commerce, analytics, and edge services joined with typed contracts, webhooks, and ownership — not ad-hoc glue.

OpenAI

LLM APIs — integrated deliberately into delivery with OpenAI.

Hugging Face

Models — integrated deliberately into delivery with Hugging Face.

Next.js

Product UI — integrated deliberately into delivery with Next.js.

Node.js

BFF clients — integrated deliberately into delivery with Node.js.

AWS S3

Documents — integrated deliberately into delivery with AWS S3.

Pinecone

Vectors (opt.) — integrated deliberately into delivery with Pinecone.

Architecture

Layers we design explicitly

Boundaries, ops knobs, and rollback policy for each layer — so one team can change without rewriting everything.

Ingestion

Parse, chunk, embed, store with provenance.

ETL
OCR
Embeddings

Retrieval

Hybrid search with filters and tenant scope.

Vector
Lexical
ACL

Generation

Prompt templates, tools, and model routing.

LLM
Tools
Cache

API edge

FastAPI with auth, quotas, and schemas.

JWT
Pydantic
Rate limit

Eval & ops

Offline sets, online feedback, traces.

MLflow
Sentry
Dashboards

Capabilities

What we actually deliver

Concrete workstreams with owners, acceptance checks, and a path for your engineers to extend after handoff.

Production FastAPI services

Auth, schemas, and containers — notebooks stay for exploration.

Grounded generation

Retrieve first; generate second; cite sources.

Evaluation gates

Fixed review sets before model or prompt changes ship.

Data jobs

Ingestion and embedding pipelines with schedules and alerts.

Safe tool use

Permissions and audit trails around what an agent can call.

Product integration

HTTP/queue boundaries clean for Next.js and Node clients.

Prompt & version control

Prompts treated like code with review and rollback.

Cost & latency controls

Caching, model tiers, and token budgets per feature.

Observability for AI

Traces for retrieval hits, model calls, and user feedback.

Patterns

Approaches we reach for

Reference implementations and conventions in the repo — so reviews reject one-off variants that bypass the agreed shape.

Retrieve-then-generate

Never free-form over private data without grounding.

Reference implementation of “Retrieve-then-generate” lives in the repo, not only slides.

Prompt as code

Reviewed, versioned, rolled back like releases.

Reference implementation of “Prompt as code” lives in the repo, not only slides.

Tool allowlists

Agents only call approved actions.

Reference implementation of “Tool allowlists” lives in the repo, not only slides.

Offline eval gates

No prod change without scorecard movement.

Reference implementation of “Offline eval gates” lives in the repo, not only slides.

Human escalation

Low-confidence paths to operators.

Reference implementation of “Human escalation” lives in the repo, not only slides.

Tenant-aware indexes

Retrieval cannot cross customer boundaries.

Reference implementation of “Tenant-aware indexes” lives in the repo, not only slides.

Industries

Domains we apply this in

Same technical playbook, different module depth — regulation, uptime, and partner APIs baked in early.