AI Integration & Automation
Models and agents go into the product you already have with the same discipline as any other service: a contract of your own, cost limits and a log of what they did.
Most AI projects that stall do not fail because of the model. They fail because nobody defined which concrete task was being automated, or how anyone would know it worked.
Here the order flips: the task and its measure first, the model second. And whatever gets integrated enters the product as one more service, with its contract, its cost and its logging.
Where the work goes
The task before the model
We start by picking a task a person does today, that repeats and that can be measured. That gives a success criterion before the first prompt is written, and avoids building a platform for a problem nobody had.
Tools with MCP
A model is more useful when it can query and act on real data. With MCP that is exposed as tools with explicit permissions, so you know exactly what it can reach and every use is logged.
Reliable agents
An agent that chains steps will fail halfway sooner or later. Orchestrated with Temporal, each step is retryable and the state survives a restart, so one failure does not mean redoing the whole task from scratch.
Cost under control
Cost per task is measured from the start and attacked with the usual levers: caching what repeats, a small model for the easy cases and a large one only for the hard ones, and per-user limits so one odd case does not eat the month’s budget.
How it fits together
The two times of a RAG
Ingestion happens beforehand and without hurry. The query happens while someone waits. Mixing the two is the most common reason a RAG feels slow.
Ingestion, offline
DocumentChunking with overlapEmbeddingspgvector / Pinecone
Query, online
QuestionRetrieval and rerankingBounded contextAnswer with citations
↳ Both paths meet at the index: if ingestion is behind, the answer will be correct about stale data.
The loop an agent runs
An agent does not improvise. Every tool is a function with permissions, every call is logged, and there is a cap on loops and on spend.
- 01
Goal
A concrete business task, not an open-ended instruction.
- 02
The model decides
It picks which tool to use, or answers that none is needed.
- 03
Tool (MCP)
Query an API, write to the database, book something. With the user permissions.
- 04
Evaluation
Test cases that run on every prompt or model change.
- Loop cap, budget and a log of everything it did
What it includes
- Model API integration (Claude, GPT, Gemini) behind a contract of your own, so you can swap provider without touching the product.
- MCP servers and clients to give a model controlled access to tools and data.
- Agents that run multi-step tasks, orchestrated with Temporal when they need to be reliable.
- RAG pipelines: document preparation, chunking, embeddings and semantic search with pgvector or Pinecone.
- Evaluation: case sets, comparison between prompt versions and human review where it is needed.
- Cost and latency control: caching, per-user limits, streaming and picking the model per task.
- Handling sensitive data before it leaves for a model.
- Product interfaces for all of the above, in React or Next.js, with waiting and error states that were actually designed.
How the project runs
- 01We start from one concrete, measurable task, not from an AI platform.
- 02The model sits behind an interface of your own, so switching provider does not mean rewriting the product.
- 03Inputs and outputs are logged, which is the only way to improve a prompt with data instead of hunches.
- 04Together you define what the model decides and what a person keeps deciding.
What you get
- The integration in production, with its logging and limits.
- Prompts, tools and evaluations versioned in the repository.
- A report on cost per task and what was measured.
Usual stack
- Models
- Claude APIOpenAI APIGoogle GeminiHugging Face
- Integration
- Anthropic MCPLangChainFunction callingStreaming
- Retrieval
- pgvectorPineconeNeo4jRAG
- Orchestration
- TemporalCeleryPythonNestJS
- Product
- ReactNext.jsTypeScript
Where this has been done
Frequently asked questions
How do you know AI is worth it for this product?
By first picking a task a person does today, that repeats and can be measured. That gives a success criterion before the first prompt is written, and within weeks you know whether it works.
What happens with sensitive data?
What leaves and what does not gets decided before anything is connected. Personal data is trimmed or replaced before the call, tool access carries explicit permissions, and every use is logged.
Can the provider be swapped later?
Yes, if the model sits behind an interface of your own instead of scattered across the product. Then moving from Claude to GPT or Gemini is swapping one implementation, not rewriting features.
How much does it cost to run?
It is measured per task from day one, because that is the only thing that lets you decide. Then it gets attacked with the usual levers: caching what repeats, a small model for the easy cases and per-user limits so one odd case does not eat the month budget.