The model is the part you can swap. What takes engineering is the retrieval underneath
it, the evaluation set that catches a silent regression, and the containment that stops
untrusted text from becoming an instruction.
ISO 27001 certified Provider-neutral by design Under 3 minutes to first reply
What you are actually buying
What generative AI development is
Generative AI development builds systems on large language models that are grounded in your
data, evaluated against a fixed test set and defended against prompt injection.
Model-agnostic deployment keeps you free to switch providers without rewriting the
application.
153+Projects Delivered
4.9/5Across 153 Reviews
25Engineers On Staff
100%Code & IP Assigned To You
Four reasons LLM prototypes never reach production
The demo works. Then somebody asks one of these four questions and the project stops for six months.
"How do we know it is right?"
Nobody wrote down what correct looks like, so quality is assessed by whoever last
tried it. Without a fixed evaluation set the system has no definition of working, and
every change becomes a matter of opinion. This is the question that kills the most
prototypes, and it is answerable in a week.
"What if someone tricks it?"
Any system that reads text it did not write is reading input from someone who may
want it to misbehave. You cannot instruct your way out of this, and a security team
that hears you try will correctly refuse to sign off. Containment is architectural,
and it is covered under
AI governance and security.
"Where does the data go?"
Under the DPDP Act 2023 and the DPDP Rules 2025 this becomes a documented answer
rather than a shrug. Deciding which fields may reach a hosted model, which get
redacted and which require a model inside your own network is an architecture
decision, so it has to come before the architecture.
"What if we want to change model?"
Prototypes get wired directly to one provider's SDK, with its quirks spread through
the codebase. A year later a better or cheaper option exists and moving is a rewrite.
One internal interface with providers behind it costs a day at the start and saves a
quarter later.
Capabilities
What LLM integration services actually involve
Ordered by how much time they take, which is roughly the inverse of how much they get discussed.
Retrieval, which is where the quality lives
Most answer quality problems get blamed on the model and are caused by retrieval. A table
split across two chunks becomes unanswerable. A heading detached from its clause loses the
condition that made it true. We chunk with structure preserved, run hybrid keyword and
semantic search so exact identifiers match literally, and rerank when the top results are
close together.
The same layer powers our
RAG chatbot work,
where you can see it traced end to end.
Evaluation before build
We write the test cases before the system, because doing so forces the scope conversation
that would otherwise happen after launch. Fifty to two hundred real cases with expected
outcomes, including the ones the system must refuse. It runs in CI from the first commit.
One provider interface
Every model call goes through an internal abstraction. Switching provider, or routing
cheap steps to a small model and hard steps to a large one, becomes configuration rather
than surgery.
Token accounting
Cost scales with context sent, not with users. We measure tokens per request from day one
and cap budgets in the orchestrator, so a badly behaved change shows up as an alert rather
than an invoice.
Private deployment when required
Open-weight models served with vLLM inside your own VPC, for the data categories that
genuinely cannot leave. Provisioned by our
cloud team.
Containment, not cleverness
Four ways untrusted text reaches your model
Select a scenario to compare how a naively built system behaves against one with the
controls in place. The point of each pair is that the fix is structural rather than a
better instruction.
Naive system
Reads the instruction as its own
A supplier uploads a document containing text addressed to the assistant rather than to a reader. Retrieval pulls that passage in alongside legitimate content, and because everything arrives in one undifferentiated block, the model treats the embedded direction as part of its task.
Contained system
Retrieved content is data, not direction
Retrieved passages are delivered in a clearly demarcated channel the system is built to treat as reference material only. Ingestion flags documents whose text is addressed at a system rather than a reader, and the assistant has no tool that could act on such a direction anyway.
Naive system
Anyone who can email you can address the model
An assistant that summarises the inbox will eventually process a message written specifically for it. If that assistant also holds tools that can reply, forward or update a record, an external party has just acquired indirect access to those tools.
Contained system
Reading and acting are separated
The component that reads untrusted mail holds no write tools at all. Anything it proposes crosses into a second stage where a person approves before execution, so a successful injection produces a suggestion nobody accepts rather than an action. Same principle as the gates in agent development.
Naive system
Output that carries data outward
If model output is rendered without inspection, content that causes the client to fetch an external resource can carry information along with the request. The model never had to be persuaded to break a rule; the rendering layer did the work.
Contained system
Outputs are filtered before rendering
Generated content is sanitised on the way out, outbound destinations are restricted to an allow-list, and anything that would cause an automatic external fetch is stripped. Treat model output the way you would treat any user-supplied content reaching a browser.
Naive system
One instruction away from a different product
A support assistant asked to behave as something else will often oblige, because nothing outside the prompt prevents it. The damage is rarely dramatic and is frequently embarrassing, and screenshots travel.
Contained system
Topic policy enforced outside the model
A separate classification step decides whether a request is in scope before the main model sees it, and an out-of-scope request is declined by the application rather than by the model's goodwill. Off-topic attempts are logged, which is also how you learn what people actually want.
We describe these at the level of controls rather than payloads. The pattern to take away is
that every fix above lives outside the model: separate the reading component from the acting
component, keep tool permissions minimal, filter what comes out, and put a person in front of
anything consequential.
Build sequence
How we take an LLM system to production
Five steps, deliberately front-loaded with the two nobody wants to do first. Same delivery
shape as the rest of the
AI and automation practice.
1
Write the evaluation set before the system
Fifty to two hundred real cases with expected outcomes, including cases the system must refuse. This is not a testing formality; writing it forces the scope conversation that would otherwise surface three days before launch when it is expensive.
2
Classify the data and pick the deployment shape
Which fields may reach a hosted model, which get redacted or tokenised first, and which categories require a model running inside your own network. This determines the architecture, so it cannot be decided afterwards without rebuilding.
3
Build retrieval before prompting
Structure-preserving chunking, hybrid search, reranking on close calls, and measurement of retrieval quality independently from answer quality. If the right passage is not being found, no prompt will rescue the answer.
4
Contain untrusted input architecturally
Separate the component that reads untrusted content from the component that can act. Minimum tool permissions, output filtering before rendering, and a human gate on anything consequential. Reviewed by the same people who run our VAPT engagements.
5
Instrument, run the suite in CI, and hand over
Token cost per request, latency percentiles, refusal rate and evaluation scores on a dashboard. The suite runs on every prompt, index or model change. Then 100% of code, prompts, retrieval configuration and the evaluation set is assigned to you.
Which deployment shape does your workload need?
Three inputs decide almost every enterprise LLM deployment. Set them and the recommendation
updates, along with the trade-offs you would be accepting.
How sensitive is the data being sent?
What is the workload pattern?
How hard is the reasoning?
Recommended shape
Hosted model API
Standard provider endpoints with retention disabled. Fastest to build, best capability, and the right default when the data does not carry residency obligations. Keep the provider behind an internal interface so the choice stays reversible.
Regional or tenanted endpoint
A dedicated deployment in a chosen region, such as an Azure OpenAI resource or a Bedrock deployment in your account. You keep frontier capability while gaining a documented region and a single named processor for the assessment.
Private model in your VPC
Open-weight models served with vLLM inside your own network. Nothing leaves, which makes the residency question trivial. You take on GPU capacity, model updates and the capability gap on genuinely hard reasoning.
Hybrid: local first, hosted for hard steps
Routine classification and extraction run locally on a small model; only the steps that genuinely need frontier reasoning call out, with sensitive fields redacted first. More moving parts, and usually the right answer at volume.
Six stages. Select one to see what it does and the specific way it tends to go wrong.
Ingest and normalise
Documents arrive as PDFs, Word files, wiki pages and scans. Each is converted to text with its structure intact, and the source, version and effective date are recorded as metadata so retrieval can prefer current material.
Goes wrong when
Superseded versions are ingested alongside current ones. Retrieval has no way to know which is authoritative unless you tell it. Scans need proper extraction first.
Chunk with structure
Text is split into passages that keep headings attached to the content they govern, and tables intact. Chunk size is tuned against your actual questions rather than copied from a tutorial.
Goes wrong when
Fixed-length splitting cuts a table in half or separates a clause from the condition that qualifies it. The answer becomes unretrievable and the failure looks like a model problem.
Embed and index
Passages are embedded and stored in pgvector or Qdrant inside your infrastructure, with metadata filters so a query can be scoped to a product, region or effective date.
Goes wrong when
The embedding model changes and the index is not rebuilt, so old and new vectors coexist in the same space and similarity scores stop meaning anything.
Hybrid retrieve
Semantic search finds passages that mean the same thing; keyword search finds the exact product code, policy number or part reference. Running both and merging the results is materially better than either alone.
Goes wrong when
Pure vector search is used and an exact identifier fails to match, because embeddings do not preserve strings. This is the single most common retrieval defect we are asked to fix.
Rerank and threshold
A cross-encoder reorders close candidates, and a similarity floor decides whether there is a good enough source to answer at all. That floor is the difference between a grounded system and a confident one.
Goes wrong when
No threshold exists, so the top three results are always passed forward even when the best of them is irrelevant. The model then answers from whatever it was handed.
Generate with citation
The model composes an answer from the retrieved passages only, and must name which document it used. Sensitive topics can be configured to quote rather than paraphrase.
Goes wrong when
The citation is generated rather than derived from the retrieval result, so it looks authoritative and points at the wrong place. Citations must come from the pipeline, not the model.
What goes into an evaluation set
Four categories of case. The second and third are the ones almost nobody writes, and they are the ones that catch real regressions.
The obvious category. Real questions with the answer a subject expert would give, plus the document that answer should be drawn from. We score both whether the answer is right and whether the right source was retrieved, because a correct answer from the wrong passage is luck rather than reliability.
Questions with no answer in your content, questions outside the agreed topic boundary, and questions where answering would create a commitment. A system that scores well on golden cases and badly here is more dangerous than one that scores worse on both, because its failures are confident and quotable.
Inputs designed to push the system outside its scope, and documents in the corpus containing text aimed at the model. These run in CI like any other case, so a prompt change that quietly weakens containment fails the build. The set grows as our security team finds new categories during review.
Every time the system gets something wrong in production, that exact case joins the set. Over a year this becomes the most valuable part of it, and it is the reason we assign the evaluation set to you along with the code. It encodes what your organisation has learned about its own content.
Where generative AI holds up under load
Four applications with verifiable output, which is the test. Profiles are anonymised.
Proposal and tender drafting
A professional services firm indexed years of past proposals. New tenders are decomposed into requirements, each matched to the closest previously approved response, and drafted with a reference back to the source document. A partner still owns what is submitted.
Internal assistants over product terms and operating procedures, configured to quote verbatim rather than summarise on anything with regulatory weight. The refusal behaviour matters more than the fluency, and the evaluation set is weighted accordingly.
Specifications, test reports and supplier certificates condensed into a comparable structured summary. Output goes into a form with typed fields rather than free prose, which makes it checkable and makes disagreement between documents visible.
Drafting at volume where tone and claim accuracy both matter. This is one of the few places fine-tuning genuinely earns its cost, because the requirement is consistent form rather than current facts. Often scoped with marketing automation.
Four approaches routinely proposed for the same problem. The deciding question is usually how often the underlying facts change.
Comparison of prompt engineering, retrieval-augmented generation, fine-tuning and training a custom model across five criteria.
Criterion
Prompting only
RAG
Fine-tuning
Custom trained model
Teaches the system
Instructions
Facts, at question time
Form and style
A narrow task
Updating it
Edit text
Edit the document, reindex
Retrain
Retrain and revalidate
Can it cite a source?
No
Yes, from the pipeline
No
No
Setup effort
Hours
Weeks
Weeks plus a labelled dataset
Months, with data science
Use when
The task is generic
Answers must reflect your current content
Output shape must be consistent
The task is narrow, stable and high volume
The fourth column is not generative AI at all, and for a well-defined prediction task it is
often the better and cheaper answer. That work sits under
machine learning and predictive analytics,
and we will tell you when you are in that column.
The ten that come up in almost every first conversation.
Building production systems on large language models: the retrieval layer that grounds them in your data, the evaluation harness that proves they still work, the security controls around untrusted input, and the deployment shape that satisfies your data residency rules. Prompt writing is a small part of it.
Retrieval-augmented generation searches your documents at question time and gives the model those passages as its source. It matters more than fine-tuning for most business problems because your facts change weekly, and updating a document is instant while retraining a model is not.
Rarely, and almost never as a first step. Fine-tuning teaches a model form rather than facts, so it helps with consistent output structure or a specialised tone. If the goal is for the system to know your policies, retrieval is the correct tool and it is far cheaper to keep current.
It is when content the system reads contains instructions aimed at the model rather than at a person. It cannot be fully fixed with wording, because the model has no reliable way to separate data from instruction. It is contained architecturally: least-privilege tools, output filtering, and approval gates on consequential actions.
A fixed evaluation set that runs in CI. Golden questions with expected answers, questions the system must refuse, and adversarial cases. When a provider ships a new version or someone edits a prompt, the suite runs and a regression fails the build rather than reaching a customer.
Yes. Open-weight models such as the Llama and Mistral families served with vLLM inside your own VPC keep everything local. The trade is capability and operational cost: you take on GPU capacity and model updates, and the strongest hosted models remain ahead on hard reasoning tasks.
Whichever fits the workload, and we build so that answer can change. Different tasks in one system often use different models, with cheaper fast models for routing and classification and a stronger model reserved for the step that genuinely needs reasoning.
Tokens, not users. Cost scales with how much context you send on every call and how many calls each task makes, which is why a carelessly built system can cost several times a careful one for identical output. We instrument per-request token use and set budget caps as a build requirement.
It is classified before it gets near one. Fields that must not leave are redacted or tokenised at the boundary, and where a whole category of data cannot go to a hosted API, that workload routes to a model running inside your own network instead. The rule is written down, not implied.
You do. On final milestone approval, 100% of the source code, prompts, retrieval configuration, evaluation set and intellectual property is assigned to the client with no recurring license. The evaluation set in particular is the asset that keeps its value longest.