CriogenAI 0.1.5: MCP tools, a local trace viewer, evals and collections

# A server this app starts (stdio): any MCP server, in any language.
files = await mcp.stdio("npx", ["-y", "@modelcontextprotocol/server-filesystem", "./notes"], prefix="files")

# A server at a URL (Streamable HTTP), with a token in a header.
docs = await mcp.http(
    "https://mcp.example.com/mcp",
    headers={"Authorization": f"Bearer {os.environ['DOCS_MCP_TOKEN']}"},
    prefix="docs",
)

agent = Agent(
    "openai:gpt-5-mini",
    tools=[files, docs.tool("docs_search")],  # a server = all its tools, or pick some
    approve=["files_write_file"],  # MCP tools work with approvals like any tool
)
result = await agent.run("Summarize what ./notes says about the Q3 launch.")
print(result.text)

await files.close()
await docs.close()

// A server this app starts (stdio): any MCP server, in any language.
const files = await mcp.stdio("npx", ["-y", "@modelcontextprotocol/server-filesystem", "./notes"], { prefix: "files" });

// A server at a URL (Streamable HTTP), with a token in a header.
const docs = await mcp.http("https://mcp.example.com/mcp", {
  headers: { Authorization: `Bearer ${process.env.DOCS_MCP_TOKEN}` },
  prefix: "docs",
});

const agent = new Agent({
  model: openai("gpt-5-mini"),
  tools: [files, docs.tool("docs_search")], // a server = all its tools, or pick some
  approve: ["files_write_file"], // MCP tools work with approvals like any tool
});
const result = await agent.run("Summarize what ./notes says about the Q3 launch.");
console.log(result.text);

await files.close();
await docs.close();

use criogenai_agent::{Agent, mcp::McpServer};
use criogenai_providers::{Endpoint, ProviderModel};

// A server this app starts (stdio): any MCP server, in any language.
let files = McpServer::stdio(
    "npx",
    ["-y", "@modelcontextprotocol/server-filesystem", "./notes"],
)
.prefix("files")
.connect()
.await?;

// A server at a URL (Streamable HTTP), with a token in a header.
let token = std::env::var("DOCS_MCP_TOKEN")?;
let docs = McpServer::http("https://mcp.example.com/mcp")
    .header("Authorization", format!("Bearer {token}"))
    .prefix("docs")
    .only(["search"])
    .connect()
    .await?;

let model = ProviderModel::new(
    Endpoint::openai(std::env::var("OPENAI_API_KEY")?),
    "gpt-5-mini",
)?;
let agent = Agent::builder(model)
    .tools(files.tools())
    .tools(docs.tools())
    .build()?;
let result = agent
    .run("Summarize what ./notes says about the Q3 launch.")
    .await?;
println!("{}", result.text().unwrap_or_default());

files.close().await;

# In a terminal: python -m criogenai.trace   (then open http://127.0.0.1:4318)
from criogenai import Agent, Telemetry

traces = Telemetry.local()  # capture_content=True to see prompts and outputs too
agent = Agent("openai:gpt-5-mini", telemetry=traces)
await agent.run("Where is order A-1001?")
await traces.flush()

// In a terminal: npx criogenai trace   (then open http://127.0.0.1:4318)
const traces = Telemetry.local(); // { captureContent: true } to see prompts and outputs too
const agent = new Agent({ model: "openai:gpt-5-mini", telemetry: traces });
await agent.run("Where is order A-1001?");
await traces.flush();

// In a terminal: criogenai-trace   (then open http://127.0.0.1:4318)
use criogenai_telemetry::{OtlpConfig, OtlpExporter};

let traces = OtlpExporter::start(OtlpConfig::local())?; // .capture_content(true) for prompts
agent
    .run_with(
        "Where is order A-1001?",
        agent.run_options().observe(traces.observer()),
    )
    .await?;
traces.flush().await;

from criogenai import evals

data = evals.Dataset.load("cases.jsonl")  # {"input": "...", "expected": "..."} per line
result = await evals.evaluate(
    agent,
    data,
    [
        evals.contains(),  # the answer mentions what was expected
        evals.tool_called("lookup_order"),  # and the agent looked it up
        evals.max_latency(5_000),
        evals.judge("openai:gpt-5-mini", "Polite, accurate, and no promises we cannot keep."),
    ],
    concurrency=8,
)
print(result.report())
result.save("eval.json")

# In CI: fail when quality drops against the last good run.
result.check(min_pass_rate=0.9, baseline=evals.EvalResult.load("baseline.json"))

const data = await evals.Dataset.load("cases.jsonl"); // {"input": "...", "expected": "..."} per line
const result = await evals.evaluate(
  agent,
  data,
  [
    evals.contains(), // the answer mentions what was expected
    evals.toolCalled("lookup_order"), // and the agent looked it up
    evals.maxLatency(5_000),
    evals.judge("openai:gpt-5-mini", "Polite, accurate, and no promises we cannot keep."),
  ],
  { concurrency: 8 },
);
console.log(result.report());
await result.save("eval.json");

// In CI: fail when quality drops against the last good run.
result.check({ minPassRate: 0.9, baseline: await evals.EvalResult.load("baseline.json") });

use std::time::Duration;

use criogenai_agent::evals::{self, Check, Dataset, EvalOptions, EvalResult};

let data = Dataset::load("cases.jsonl")?; // {"input": "...", "expected": "..."} per line
let result = evals::evaluate(
    agent,
    &data,
    vec![
        evals::contains(),                     // the answer mentions what was expected
        evals::tool_called("lookup_order", 1), // and the agent looked it up
        evals::max_latency(Duration::from_secs(5)),
    ],
    EvalOptions::default().concurrency(8),
)
.await?;
println!("{}", result.report());
result.save("eval.json", true)?;

// In CI: fail when quality drops against the last good run.
result.check(
    &Check::new()
        .min_pass_rate(0.9)
        .baseline(EvalResult::load("baseline.json")?),
)?;

from criogenai import Agent, Collection, Embedder

handbook = await Collection.open("handbook", embedder=Embedder.openai(), storage=storage)
await handbook.add(
    [
        {"id": "leave", "text": "Annual leave is 25 days a year.", "metadata": {"section": "hr"}},
        {"id": "expenses", "text": "Expenses are paid within 30 days.", "metadata": {"section": "finance"}},
    ]
)

hits = await handbook.search("How many vacation days?", k=3)
hr_only = await handbook.search("deadlines", k=3, where={"section": "hr"})

agent = Agent(
    "openai:gpt-5-mini",
    instructions="Answer from the handbook; say which section you used.",
    tools=[handbook.as_tool("search_handbook", "Search the staff handbook.")],
)
print((await agent.run("How much leave do I get?")).text)

const handbook = await Collection.open("handbook", { embedder: Embedder.openai(), storage });
await handbook.add([
  { id: "leave", text: "Annual leave is 25 days a year.", metadata: { section: "hr" } },
  { id: "expenses", text: "Expenses are paid within 30 days.", metadata: { section: "finance" } },
]);

const hits = await handbook.search("How many vacation days?", { k: 3 });
const hrOnly = await handbook.search("deadlines", { k: 3, where: { section: "hr" } });

const agent = new Agent({
  model: openai("gpt-5-mini"),
  instructions: "Answer from the handbook; say which section you used.",
  tools: [handbook.asTool("search_handbook", "Search the staff handbook.")],
});
console.log((await agent.run("How much leave do I get?")).text);

use std::sync::Arc;

use criogenai_agent::Agent;
use criogenai_agent::retrieval::{Collection, Document};
use criogenai_providers::{Endpoint, ProviderEmbedder, ProviderModel};
use criogenai_storage::Storage;

let key = std::env::var("OPENAI_API_KEY")?;
let storage = Storage::connect("sqlite://handbook.db").await?;
let embedder = Arc::new(ProviderEmbedder::new(
    Endpoint::openai(key.clone()),
    "text-embedding-3-small",
)?);
let handbook = Collection::open(storage.memory().clone(), "handbook", embedder).await?;
handbook
    .add(vec![
        Document::new("leave", "Annual leave is 25 days a year.").meta("section", "hr"),
        Document::new("expenses", "Expenses are paid within 30 days.")
            .meta("section", "finance"),
    ])
    .await?;

let hits = handbook.search("How many vacation days?", 3).await?;
println!("{}", hits[0].text);

let model = ProviderModel::new(Endpoint::openai(key), "gpt-5-mini")?;
let agent = Agent::builder(model)
    .tool(handbook.as_tool("search_handbook", "Search the staff handbook."))
    .build()?;
agent.run("How much leave do I get?").await?;