Skip to main content
This quickstart example will teach you how to get started with Adaptive Engine, by mocking an AI customer support co-pilot use case. You’ll be taken through the following steps to deploy, use, and adapt your first model:
  1. Install the Adaptive Python SDK
  2. Create a new use case
  3. Deploy a model and make an inference request
  4. Log feedback on the model’s completion
  5. Creating a training dataset with the logged feedback
  6. Adapting a model using reinforcement learning on the logged feedback

​
Step-by-step walkthrough

1

Install the Adaptive Python SDK

First, you pip install the Adaptive SDK.
pip install adaptive_sdk
Instantiate the Adaptive client.
Adaptive SDK
from adaptive_sdk import Adaptive

adaptive = Adaptive(
    base_url="ADAPTIVE_URL",
    api_key="ADAPTIVE_API_KEY"
)
2

Create a new use case

An Adaptive Engine use case is a user-defined workspace where you group together resources such as models, interaction logs and metrics for monitoring and evaluation.You first create a Customer Support Assistant use case that to service your customer support operations.
Adaptive SDK
use_case = adaptive.use_cases.create(
    key="customer_support_assistant"
)
3

Deploy a model and make an inference request

You deploy the Llama 3.1 70B instruction-tuned model and attach it to the use case, so your customer support agents can start using it. This is a capable base model that can provide satisfactory performance initially. Learn more about other supported models.
Adaptive SDK
# configure default client use case
# SDK methods will target the customer support use case going forward, unless specifically overridden
client = adaptive.set_default_use_case(use_case.key)

model = adaptive.models.attach(
    model="llama-3.3-70b-instruct",
)
You can now integrate the Adaptive SDK in your customer support application, and start making inference requests. The Adaptive Chat API is also compatible with the OpenAI Python library, so there is no need to refactor application code if you were previously using it.
Adaptive SDK
chat_response = adaptive.chat.create(
    model=model.key,
    messages=[
        {
            "role": "system",
            "content": "You are a helpful customer support assistant."
        },
        {
            "role": "user",
            "content": "I was blocked out of my account, I don't know why."
        }
    ]
)
print(chat_response.choices[0].message.content)
Output:
Have you tried recovering your password?
Pairs of messages, completion resulting from chat requests are automatically logged and saved on Adaptive.
4

Log feedback on the model's completion

Your customer support agent who is using the model as an assistant finds the model’s completion appropriate, and accepts it to be sent to the customer.To log and aggregate this feedback, you register a new Acceptance feedback key, link it to your use case, and log the agent’s feedback against the completion_id.
Adaptive SDK
feedback_key = adaptive.feedback.register_key(
    key="acceptance",
    kind="bool",
    scoring_type="higher_is_better",
)
_ = adaptive.feedback.link(feedback_key.key)

completion_id = chat_response.choices[0].completion_id

feedback = adaptive.feedback.log_metric(
    completion_id=completion_id,
    feedback_key=feedback_key.key,
    value=True,
)
Learn more about feedback types in Adaptive.
5

Create a training dataset from past interactions

Once you have a satisfying amount of interactions with feedback - typically in the magnitude of few thousands or more, you can export them as a training dataset from the Interactions page:
  1. Filter on Acceptance=any, so that both positive and negative feedback are collected.
  2. Add additional optional filters as needed, for example generating model, creation date, other metrics and labels.
  3. Use the checkbox to select records and create a dataset of type prompt, interaction, feedback.
6

Adapt a model on previous interaction feedback

After running your customer support operations with the help of Adaptive Engine, you have accumulated feedback from your human agents in production. To align a model to the preferences of your human agents, you adapt a smaller 4B model on the feedback you logged. This tunes the smaller model using reinforcement learning methods, learning from the successes and failures of the larger, more capable model.
Adaptive SDK

adaptive.jobs.run(
    recipe_key='metric_rlhf',
    num_gpus='4',
    compute_pool='default',  # the name of a compute pool in your Adaptive Engine cluster
    args={
        'dataset': {
            'dataset_key': '<training dataset key>',  # copy dataset key from the dataset list in UI
            'feedback_key': 'acceptance'
        },
        'kl_beta': 0.1,
        'max_num_steps': 100,
        'model_to_train': 'gemma-3-4b',
        'output_model_key': 'my-tuned-model',
        'policy_learning_rate': 7.5e-7,
        'policy_model_max_batch_tokens': 12000,
        'policy_tp': 1,
        'rl_training_method': {
            'clip_range': 1,
            'policy_learning_rate': 7.5e-7,
            'reward_base_model': 'Qwen3-30B-A3B-Instruct-2507',  # a bigger, more capable model
            'reward_model_max_batch_tokens': 12000,
            'reward_model_tp': 2,
            'samples_per_batch': 128,
            'union_variant': 'GRPOParams'
        },
        'train_adapter': True  # train an adapter.
    }
)
The job trains and saves a new, improved model that you can immediately deploy for better results! Learn more in Adapt a model.

​
Next steps

  • Dive deeper into training with Adaptive Engine.