# Tensorant

> Tensorant is a platform for fine-tuning, evaluating and serving open-weight language and vision models. Teams turn their own data into a reviewed training dataset, fine-tune models such as Qwen, Llama, Mistral, gpt-oss and Gemma with SFT or DPO (LoRA or QLoRA), compare the tuned model with the base model on a held-out test set, and call it through an OpenAI-compatible API. Training runs on GPUs in the customer's own cloud account, and the data stays in the customer's own storage.

Key facts:

- GPUs: training runs in the customer's own RunPod, Verda, Lambda, AWS or Azure account, and serving in their RunPod account, always on or waking on request with RunPod Serverless. The provider bills GPU time directly at its own prices; Tensorant adds no markup. Every run and deployment has an hour limit and an hourly price limit.
- Data: uploads (TXT, Markdown, CSV, TSV, JSON, JSONL, YAML, HTML, PDF, DOCX, XLSX), pasted text and Hugging Face datasets. Recipes have a model write examples from documents, quality checks flag problems before review, and a version splits the approved examples into training, validation and test sets. Content is kept in the customer's S3-compatible bucket or RunPod network volume.
- Models: chat models from Hugging Face in the Qwen, Llama, Mistral, gpt-oss, Phi-3 and GPT-NeoX families, and vision models such as Gemma 4 and Qwen3.8 that read images as well as text. A trained adapter downloads as standard LoRA files that load with PEFT, or publishes to the customer's Hugging Face account.
- Ways to work: the web console (https://app.tensorant.io), the OpenAI-compatible API (https://api.tensorant.io/v1), the `tensorant` CLI for terminals and CI, and an MCP server (https://mcp.tensorant.io/mcp) for AI assistants such as Claude Code, Cursor and Codex.
- Pricing: Free ($0), Starter ($49 a month), Pro ($199 a month) and Enterprise (custom pricing). Pro adds images (vision) and 10 seats. Every organization starts on Free, with no card. See https://tensorant.io/pricing.
- Contact: contact@tensorant.io

## Product

- [Datasets](https://tensorant.io/product/datasets): Bring your documents, conversations, and Hugging Face datasets into one review workflow. Turn the examples you trust into a version you can train and evaluate.
- [Fine-tuning](https://tensorant.io/product/fine-tuning): Fine-tune on your reviewed data with SFT or DPO, using LoRA or 4-bit QLoRA. Tensorant manages the training workflow on GPUs in your connected cloud account.
- [Evaluations](https://tensorant.io/product/evaluations): Compare your base model and fine-tuned adapter on the same held-out examples. Measure the task you care about, then inspect the answers behind the score.
- [LLM inference](https://tensorant.io/product/inference): Publish a base model, trained adapter, or supported Hugging Face model under a name your application can call. Serve it on demand or keep it ready for steady traffic.
- [CLI](https://tensorant.io/product/cli): Prepare datasets, run experiments, and inspect results without leaving your shell. Use the Tensorant CLI interactively or build repeatable workflows with configuration files and JSON output.
- [MCP](https://tensorant.io/product/mcp): Connect Claude Code, Cursor, Codex, or another compatible MCP client to Tensorant. Ask your assistant to inspect data, prepare a dataset, compare evaluations, or manage a training experiment.
- [Pricing](https://tensorant.io/pricing): the plans, every limit of every plan, and billing questions

## Docs

- [Documentation overview](https://tensorant.io/docs): Turn your data into a fine-tuned model. Prepare, train, evaluate, and deploy on your own infrastructure, with a clear path from first dataset to first API call.

## Docs: Get started

- [What Tensorant is](https://tensorant.io/docs/get-started/what-is-tensorant): What Tensorant does, how the console is laid out, where your data and GPUs live, and what you pay for.
- [Quickstart](https://tensorant.io/docs/get-started/quickstart): From sign-up to calling your own fine-tuned model, in seven short steps.
- [Accounts, organizations and roles](https://tensorant.io/docs/get-started/accounts-and-roles): Sign up and sign in, create your organization or accept an invitation, see what each role can do, and manage your account.
- [Connections](https://tensorant.io/docs/get-started/connections): Connect RunPod, Verda, Lambda, AWS or Azure for training, choose S3 or RunPod storage, and configure model endpoints and Hugging Face access.

## Docs: Cloud providers

- [Cloud providers](https://tensorant.io/docs/providers): Choose a GPU provider and storage, connect your accounts, and understand what training and serving require.
- [RunPod](https://tensorant.io/docs/providers/runpod): Connect a RunPod account, create API credentials, and choose network storage or S3 for training.
- [Verda](https://tensorant.io/docs/providers/verda): Set up Verda credentials, an SSH key and location, then connect storage and launch a training trial.
- [Lambda](https://tensorant.io/docs/providers/lambda): Connect Lambda Cloud with an API key, registered SSH key, region and compatible GPU image.
- [AWS](https://tensorant.io/docs/providers/aws): Connect AWS with one CloudShell command, request GPU quota, and verify training and recovery.
- [Azure](https://tensorant.io/docs/providers/azure): Connect Azure with one Cloud Shell command, request GPU quota, and verify training and recovery.
- [Custom S3](https://tensorant.io/docs/providers/s3): Connect private AWS S3, Cloudflare R2 or compatible object storage independently of your GPU cloud.

## Docs: Data

- [Projects and base models](https://tensorant.io/docs/data/projects): Create a project for one base model, pick a use case, and change, switch or delete projects.
- [Sources](https://tensorant.io/docs/data/sources): Add documents and examples to a project from files, pasted text or a Hugging Face dataset.
- [Vision models](https://tensorant.io/docs/data/vision-models): Train and serve models that read images with text and answer in text.
- [Recipes](https://tensorant.io/docs/data/recipes): Generate training examples from your documents with a model endpoint and a recipe.
- [Review](https://tensorant.io/docs/data/review): Read, fix, approve or reject examples before they go into a version.
- [Versions](https://tensorant.io/docs/data/versions): Create a numbered version of your approved examples with training, validation and test splits, check it before training and download it.

## Docs: Train

- [Training runs](https://tensorant.io/docs/train/training-runs): Train a LoRA or QLoRA adapter on a version, using one GPU from your connected cloud provider.
- [Experiments](https://tensorant.io/docs/train/experiments): Measure the base model, train an adapter, compare the two and release the GPUs, in one guided workflow.
- [DPO preference training](https://tensorant.io/docs/train/dpo): Train with preferred and less preferred answers, using text or image prompts with LoRA or QLoRA.

## Docs: Evaluate

- [Evaluations](https://tensorant.io/docs/evaluate/evaluations): Score the base model and your adapters on a version's test examples, and compare them answer by answer.

## Docs: Serve

- [Playground](https://tensorant.io/docs/serve/playground): Try a model by hand, compare two models side by side, and get the code that calls a published model.
- [Test sessions](https://tensorant.io/docs/serve/deployments): Run the base model, a trained adapter or another Hugging Face model on a GPU in your RunPod account, to try it in the Playground, evaluations and generation.
- [API models](https://tensorant.io/docs/serve/publishing): Give the base model, a trained adapter or another Hugging Face model a name your applications call through the API, waking on request or always on.
- [Advanced serving settings](https://tensorant.io/docs/serve/serving-settings): Tune memory, throughput and precision of the serving engine for deployments, experiments and published models.
- [Publishing adapters to Hugging Face](https://tensorant.io/docs/serve/hugging-face): Upload a trained adapter and a model card to your own Hugging Face repository, private by default.

## Docs: Use the API

- [API quickstart](https://tensorant.io/docs/api/quickstart): Create an API key and call a published model with curl, Python or JavaScript.
- [Chat completions](https://tensorant.io/docs/api/chat-completions): The reference for the chat completions and models routes, their fields, responses, limits and errors.
- [Keys and usage](https://tensorant.io/docs/api/keys-and-usage): Create, limit and revoke API keys, and see how much each key used each model.

## Docs: Use MCP

- [MCP](https://tensorant.io/docs/mcp): Connect an AI agent to work with your Tensorant projects, data, training runs and models.
- [MCP quickstart](https://tensorant.io/docs/mcp/quickstart): Connect an agent to Tensorant with Claude Code and a sign-in in your browser, then ask it about your projects.
- [Connect your app](https://tensorant.io/docs/mcp/connect): Add Tensorant to Claude Code, Cursor, Codex, VS Code, Claude or ChatGPT, with a browser sign-in or a personal token.
- [Tools](https://tensorant.io/docs/mcp/tools): The tools an agent gets at each access level, how spending works, how files get in, and what stays in the console.
- [Access and tokens](https://tensorant.io/docs/mcp/access-and-tokens): Choose what an agent may do, connect with a browser sign-in or a personal token, revoke agents, and see the limits.

## Docs: Use the CLI

- [CLI](https://tensorant.io/docs/cli): Import local data, repeat training configurations, compare evaluations and retrieve outputs from your terminal or CI.
- [CLI quickstart](https://tensorant.io/docs/cli/quickstart): Install the Tensorant CLI, sign in, import a local dataset and create a frozen version from your terminal.
- [Command reference](https://tensorant.io/docs/cli/commands): Tensorant CLI commands for projects, files, versions, training, evaluations, experiments, serving and downloads.
- [Authentication and profiles](https://tensorant.io/docs/cli/authentication): Sign in safely, select organization profiles and supply personal tokens to scripts without storing them in your repository.
- [Automation and configuration](https://tensorant.io/docs/cli/automation): Save repeatable training and experiment settings, enforce evaluation thresholds in CI and bound paid launches.

## Docs: Organization

- [Members and invitations](https://tensorant.io/docs/organization/members): Invite people to your organization, change their roles, remove members, and rename the organization.
- [Plans and billing](https://tensorant.io/docs/organization/plans-and-billing): Compare the Free, Starter, Pro and Enterprise plans, see your usage, upgrade or switch online, cancel, and know what happens when a limit is reached.
- [Activity and the audit trail](https://tensorant.io/docs/organization/activity): Follow, cancel, retry and clear a project's background jobs, and read the owners' record of every change in the organization.
- [Email notifications](https://tensorant.io/docs/organization/email-notifications): See what Tensorant emails you about and who gets each email, choose which job and model updates you get, and unsubscribe from a link.

## Docs: Reference

- [Reference](https://tensorant.io/docs/reference): Check supported models, platform limits and troubleshooting steps before configuring or recovering a workflow.
- [Supported models](https://tensorant.io/docs/reference/supported-models): The text and vision model families you can train and serve, what a base model needs, and how much GPU memory it takes.
- [Limits](https://tensorant.io/docs/reference/limits): The limits you can run into, by area, with links to the pages that explain them.
- [Troubleshooting](https://tensorant.io/docs/reference/troubleshooting): Common problems by area, with the message you see and how to fix it.

## Guides

- [Fine-tune Qwen on RunPod with Tensorant](https://tensorant.io/guides/qwen-fine-tuning-runpod): Build a support-ticket classifier with Qwen, review labeled examples, compare a LoRA adapter against the base model, and publish an API.
- [LoRA vs QLoRA: choose a fine-tuning method](https://tensorant.io/guides/lora-vs-qlora): Understand LoRA and QLoRA memory tradeoffs, choose practical settings, and compare adapters fairly in Tensorant before deployment.
- [Fine-tuning vs RAG: build a grounded support assistant](https://tensorant.io/guides/fine-tuning-vs-rag): Choose retrieval, fine-tuning, or both for a support assistant, with source-conditioned examples, held-out evaluation, and Tensorant API steps.
- [Estimate LLM fine-tuning cost before launching](https://tensorant.io/guides/llm-fine-tuning-cost): Budget training, base-versus-tuned evaluation, storage, iteration, and inference with Tensorant's provider controls and transparent cost formulas.
- [How to evaluate a fine-tuned LLM against its base model](https://tensorant.io/guides/evaluate-fine-tuned-llm): Build useful LLM evals in Tensorant, score a support-ticket classifier, compare base and tuned models, and investigate regressions before deployment.
- [How to prevent data leakage in LLM evaluation](https://tensorant.io/guides/llm-evaluation-data-leakage): Prepare held-out LLM evals in Tensorant, separate related sources and prompts, review near-duplicates, and preserve trustworthy tests as your dataset grows.
- [Deploy a LoRA adapter as an LLM API on RunPod](https://tensorant.io/guides/deploy-lora-adapter): Publish a fine-tuned support-routing model in Tensorant, choose its RunPod serving mode, and call an LLM API with secure keys and bounded retries.
- [Serverless vs dedicated GPU inference for fine-tuned LLMs](https://tensorant.io/guides/serverless-vs-dedicated-inference): Choose RunPod Serverless or a dedicated GPU for LLM inference using cold starts, traffic patterns, worker costs, and Tensorant's publishing controls.

## Optional

- [Full documentation in one file](https://tensorant.io/llms-full.txt): every docs page as Markdown, in reading order
- [Terms of Service](https://tensorant.io/terms)
- [Privacy Policy](https://tensorant.io/privacy)