AI is easy to productionize
The AI developer platform to build AI agents, applications,
and models with confidence
import weave
weave.init("quickstart")
@weave.op()
def llm_app(prompt):
pass # Track LLM calls, document retrieval, agent steps
import wandb
run = wandb.init(project="my-model-training-project")
run.config = {"epochs": 1337, "learning_rate": 3e-4}
run.log({"metric": 42})
my_model_artifact = run.log_artifact("./my_model.pt", type="model")
The world’s leading AI teams trust Weights & Biases
Weights & Biases AI developer platform
Models
Build and manage AI models
Training
Fine-tune with serverless RL
Inference
Access and explore hosted AI models
Weave
Iterate, evaluate and monitor agents
Registry
Datasets | Models | Prompts | Code | Metadata
Core
Reports | Automations | SDK
Secure deployment
Saas | Dedicated | Customer-managed
Models
Build and manage AI models
Training
Fine-tune with serverless RL
Inference
Access and explore hosted AI models
Weave
Iterate, evaluate and monitor agents
Registry
Datasets | Models | Prompts | Code | Metadata
Core
Reports | Automations | SDK
Secure deployment
Saas | Dedicated | Customer-managed
Compliance-ready for the enterprise
Weights & Biases AI development platform is certified under ISO/IEC 27001:2022, ISO/IEC 27017:2015, and ISO/IEC 27018:2019, and is compliant with SOC 2 and HIPAA standards. Our platform also helps customers comply with NIST 800-53 and we are in alignment with GDPR requirements for processing personal information.
Learn more about compliance with different deployment options:
Certified under
ISO 27001:2022
ISO 27017:2015
ISO 27018:2019
Compliant with
SOC 2
HIPAA
NIST 800-53
GDPR
Get started with one line of code
“I love Weave for a number of reasons. The fact that I could just add a library to our code and all of a sudden I’ve got a whole bunch of information about the GenAI portion of our product, in Weights & Biases, which I was already using and very familiar with. All those things that I’m watching for the performance of our AI, I can now report on quickly and easily with Weave.”
import openai, weave
weave.init("weave-intro")
@weave.op
def correct_grammar(user_input):
client = openai.OpenAI()
response = client.chat.completions.create(
model="o1-mini",
messages=[{
"role": "user",
"content": "Correct the grammar:\n\n" +
user_input,
}],
)
return response.choices[0].message.content.strip()
result = correct_grammar("That was peace of cake!")
print(result)
import weave
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
# Initialize Weave with your project name
weave.init("langchain_demo")
llm = ChatOpenAI()
prompt = PromptTemplate.from_template("1 + {number} = ")
llm_chain = prompt | llm
output = llm_chain.invoke({"number": 2})
print(output)
import weave
from llama_index.core.chat_engine import SimpleChatEngine
# Initialize Weave with your project name
weave.init("llamaindex_demo")
chat_engine = SimpleChatEngine.from_defaults()
response = chat_engine.chat(
"Say something profound and romantic about fourth of July"
)
print(response)
import wandb
# 1. Start a new run
run = wandb.init(project="gpt5")
# 2. Save model inputs and hyperparameters
config = run.config
config.dropout = 0.01
# 3. Log gradients and model parameters
run.watch(model)
for batch_idx, (data, target) in enumerate(train_loader):
...
if batch_idx % args.log_interval == 0:
# 4. Log metrics to visualize performance
run.log({"loss": loss})
import wandb
# 1. Define which wandb project to log to and name your run
run = wandb.init(project="gpt-5",
run_name="gpt-5-base-high-lr")
# 2. Add wandb in your `TrainingArguments`
args = TrainingArguments(..., report_to="wandb")
# 3. W&B logging will begin automatically when your start training your Trainer
trainer = Trainer(..., args=args)
trainer.train()
from lightning.pytorch.loggers import WandbLogger
# initialise the logger
wandb_logger = WandbLogger(project="llama-4-fine-tune")
# add configs such as batch size etc to the wandb config
wandb_logger.experiment.config["batch_size"] = batch_size
# pass wandb_logger to the Trainer
trainer = Trainer(..., logger=wandb_logger)
# train the model
trainer.fit(...)
import wandb
# 1. Start a new run
run = wandb.init(project="gpt4")
# 2. Save model inputs and hyperparameters
config = wandb.config
config.learning_rate = 0.01
# Model training here
# 3. Log metrics to visualize performance over time
with tf.Session() as sess:
# ...
wandb.tensorflow.log(tf.summary.merge_all())
import wandb
from wandb.keras import (
WandbMetricsLogger,
WandbModelCheckpoint,
)
# 1. Start a new run
run = wandb.init(project="gpt-4")
# 2. Save model inputs and hyperparameters
config = wandb.config
config.learning_rate = 0.01
... # Define a model
# 3. Log layer dimensions and metrics
wandb_callbacks = [
WandbMetricsLogger(log_freq=5),
WandbModelCheckpoint("models"),
]
model.fit(
X_train, y_train, validation_data=(X_test, y_test),
callbacks=wandb_callbacks,
)
import wandb
wandb.init(project="visualize-sklearn")
# Model training here
# Log classifier visualizations
wandb.sklearn.plot_classifier(clf, X_train, X_test, y_train, y_test, y_pred, y_probas, labels,
model_name="SVC", feature_names=None)
# Log regression visualizations
wandb.sklearn.plot_regressor(reg, X_train, X_test, y_train, y_test, model_name="Ridge")
# Log clustering visualizations
wandb.sklearn.plot_clusterer(kmeans, X_train, cluster_labels, labels=None, model_name="KMeans")
import wandb
from wandb.xgboost import wandb_callback
# 1. Start a new run
run = wandb.init(project="visualize-models")
# 2. Add the callback
bst = xgboost.train(param, xg_train, num_round, watchlist, callbacks=[wandb_callback()])
# Get predictions
pred = bst.predict(xg_test)