cargo add mubit-sdk

import { learn } from "@mubit-ai/sdk/learn";

// One-time setup
const runManager = learn.init({ apiKey: process.env.MUBIT_API_KEY, agentId: "support-agent" });

// Run-scoped learning with automatic reflection
const result = await learn.withRun({ agentId: "support-agent" }, async () => {
  return client.chat.completions.create({
    model: "gpt-4o",
    messages: [{ role: "user", content: "What update style does Taylor want?" }],
  });
});

use mubit_sdk::learn::{LearnSession, LearnConfig};

let session = LearnSession::new(
    LearnConfig::from_env().agent_id("support-agent")
).await;

// Enrich messages with lessons before your LLM call
let enriched = session.enrich_messages(&messages).await;
// Make LLM call with enriched messages...
session.record("response", "gpt-4o", 1500.0).await;
session.end().await; // triggers reflection

import { Client } from "@mubit-ai/sdk";

const runId = "support:acme:ticket-42";
const client = new Client({
  api_key: process.env.MUBIT_API_KEY,
  run_id: runId,
  transport: process.env.MUBIT_TRANSPORT ?? "auto",
});

await client.remember({
  session_id: runId,
  agent_id: "support-agent",
  content: "Customer Taylor prefers concise Friday updates.",
  intent: "fact",
  metadata: { customer: "taylor", source: "quickstart" },
});

const answer = await client.recall({
  session_id: runId,
  query: "What update style does Taylor want?",
  entry_types: ["fact", "lesson", "rule"],
});

const context = await client.getContext({
  session_id: runId,
  query: "Draft the next customer update.",
  mode: "summary",
  max_token_budget: 300,
});

console.log(answer.final_answer);
console.log(context.section_summaries ?? []);

use mubit_sdk::{Client, ClientConfig, GetContextOptions, RecallOptions, RememberOptions};
use serde_json::json;
use std::env;

let run_id = "support:acme:ticket-42".to_string();
let config = ClientConfig::new("https://api.mubit.ai")
    .api_key(env::var("MUBIT_API_KEY")?)
    .run_id(&run_id);
let client = Client::connect(config).await?;

let mut remember = RememberOptions::new("Customer Taylor prefers concise Friday updates.");
remember.run_id = Some(run_id.clone());
remember.agent_id = Some("support-agent".to_string());
remember.intent = Some("fact".to_string());
remember.metadata = Some(json!({"customer":"taylor","source":"quickstart"}));
client.remember(remember).await?;

let mut recall = RecallOptions::new("What update style does Taylor want?");
recall.run_id = Some(run_id.clone());
recall.entry_types = vec!["fact".to_string(), "lesson".to_string(), "rule".to_string()];
let answer = client.recall(recall).await?;

let mut context = GetContextOptions::default();
context.run_id = Some(run_id.clone());
context.query = Some("Draft the next customer update.".to_string());
context.mode = Some("summary".to_string());
context.max_token_budget = Some(300);
let context = client.get_context(context).await?;

println!("{}", answer["final_answer"]);
println!("{}", context["section_summaries"]);