Login AI
LLM fine-tuning on your data
We prepare the dataset, train an adapter or a full model, and deploy it in your perimeter on vLLM. The metric is fixed before training, both versions run on one held-out set, and you get a report with numbers.
We tune a 7B–70B model with LoRA, SFT, or DPO and show quality on a held-out set before launch.
Pricing
from ₽800,000
per project
This is the lower bound of a project. We scope the exact quote after a brief: it depends on volume and the number of integrations.
Capabilities
Dataset preparation
We assemble 1,000–50,000 instruction-response pairs, check the labels for consistency, and split the array into training and held-out parts.
LoRA, SFT, and DPO
We pick the method for the task: LoRA trains 0.1–1% of the weights, SFT sets the answer format, and DPO tunes the choice on preference pairs.
Evaluation before and after
The base and tuned models run on one held-out set: accuracy, format compliance, and answer completeness land side by side.
Deployment in your perimeter
The model runs on vLLM inside Kubernetes, weights live in MinIO, and metrics and versions stay in PostgreSQL.
From request to result
1
Dataset audit
We review volume, labels, and topic coverage: count duplicates, check answer consistency, and find gaps in the examples.
2
Method and model choice
We pick a base model from 7B to 70B and a method: LoRA for a fast start, SFT for format, DPO for preferences. The metric and GPU budget are fixed here.
3
Training
We build the config, run jobs on 2–8 GPUs, watch loss and validation, save checkpoints, and compare versions against each other.
4
Evaluation and deployment
We run the held-out set, compare against the base model, and bring vLLM up in Kubernetes. You get a report with metrics and a runbook.
Check if it fits you
Good fit
1,000+ examples
You have 1,000 or more labeled instruction-response pairs for the target task: enough for LoRA and an honest held-out set.
A held-out set
There are 200–500 examples that stay out of training: they show whether the skill transfers to new phrasing.
Not a fit
No data yet
Without a corpus of examples, training collapses into paraphrasing the docs. Collect and label at least 1,000 pairs first.
New knowledge without RAG
Fine-tuning changes style, format, and decisions on familiar topics. Fresh facts and closed documents come from RAG, where the model reads them from an index at request time.
What you get
7B
A 7B model in the base package
The base 7B model after LoRA holds the target answer format and fits 1–2 A100 40 GB GPUs, so it can run in your perimeter around the clock.
10 GB
A 10 GB dataset
10 GB of raw logs yields a dataset of 1,000–5,000 clean instruction-response pairs with a data card and a held-out part for evaluation.
eval
Eval before and after
The evaluation layer compares the base and tuned versions on one set: accuracy, format, and answer cost show up in a single report.
What the delivery includes
Dataset
You get the labeled and cleaned dataset in JSONL: the training and held-out splits plus a data card that describes fields and labeling rules.
Adapter or model
We hand over the LoRA adapter or full weights in safetensors, the training config, and a script that reproduces the run on your infrastructure.
Evaluation report
The evaluation report holds metrics for the base and tuned model on one set, an error breakdown, and recommendations for the next cycle.
How the system is built
Data preparation
The dataset goes through cleaning and labeling: we drop duplicates, bring answers to one format, and split the array 90/10 into training and held-out parts. The held-out part stays sealed until the final evaluation.
Training
A training run goes on 2–8 GPUs: the model takes batches of 8–32 examples, the learning rate stays in the 1e-5 to 2e-4 range, and validation fires every 200 steps. Checkpoints land in MinIO, so any run can be reproduced.
Evaluation and rollout
Evaluation runs on the held-out set: we measure accuracy, format compliance, and the share of correct refusals, then compare the numbers with the base model. After sign-off, vLLM comes up in Kubernetes and traffic moves to the new version.
Where the solution pushes back
- 01
Data quality
Data quality sets the result ceiling: 1,000 clean pairs beat 20,000 noisy ones. The audit takes 3–5 days and saves weeks of training.
- 02
Catastrophic forgetting
Catastrophic forgetting shows on a narrow task: the model loses part of its general skills. We mix the target examples with 5–10% general instructions and check both sets on held-out data.
- 03
GPU cost
We price the GPU cost before the start: 7B on LoRA fits 1–2 A100 40 GB cards, 70B on 8 cards. A 7B run takes 8–20 hours, and you pay for the rental as it runs.
Technologies
The technologies we use in our work and their role in a project.
Training and serving
Training runs on PyTorch, inference on vLLM, data and artifacts sit in MinIO, metrics and versions in PostgreSQL, and Kubernetes handles rollout and scaling.
Cost calculator
This is an indicative range, not a quote. We scope the exact estimate after a brief: it depends on volume and the number of integrations.
Model size
Dataset, GB
Method
Before/after evaluation
Deployment
Add-ons
Support
Year one: updates and monitoring, a reply within 2 business days.
Service
LLM fine-tuning on your data
The estimate covers our team's work. Hardware, third-party service licences and travel are added on request.
Estimated cost
₽1M
Timeline
6 wk
Frequently asked questions
How is fine-tuning different from RAG?
RAG puts fresh fragments into the context and answers from documents. Fine-tuning changes model behavior: style, format, and handling of typical tasks. Together they give indexed facts and a stable answer format.
How much data does fine-tuning need?
LoRA needs 1,000–5,000 instruction-response pairs. SFT on 10,000–50,000 examples gives a stable format, and DPO needs 2,000–10,000 preference pairs. We size the exact volume after the dataset audit.
How long does the project take?
4–6 weeks: the data audit takes 3–5 days, preparation and training 2–3 weeks, and evaluation plus deployment another 1–2 weeks. A 7B run on 4 GPUs takes 8–20 hours, and we plan 2–3 runs.
Where does the model run after training?
In your perimeter: vLLM in Kubernetes, weights in MinIO, metrics in PostgreSQL. For an external contour, we build the same stack in your cloud and close network access.
What teams add to this service
Related Services
Part of Solutions
Implementation Examples
−70%
Request handling time
Ready to discuss your task?
Leave a request – we'll get back with a proposal and a preliminary estimate.
Contact us