SDKs, MCP and frameworks.

One request

npm install @usdf/sdk viem

import { USDF } from "@usdf/sdk";
import { privateKeyToAccount } from "viem/accounts";
const wallet = privateKeyToAccount(process.env.PAYER_KEY as `0x${string}`);
const usdf = new USDF({ wallet }); // or new USDF({ apiKey: process.env.USDF_API_KEY })
const result = await usdf.run("<model>", "Hello");

One request

pip install usdf eth-account

import os
from eth_account import Account
from usdf import USDF
wallet = Account.from_key(os.environ["PAYER_KEY"])
client = USDF(wallet=wallet)  # or USDF(api_key=os.environ["USDF_API_KEY"])
result = client.run("<model>", "Hello")

Generate text

npm install @usdf/sdk ai

import { generateText } from "ai";
import { usdf } from "@usdf/sdk/ai"; // charges USDF_API_KEY; createUSDF({ wallet }) from "@usdf/sdk/ai" pays per request from a wallet
const model = usdf("<model>");
const result = await generateText({ model, prompt: "Hello" });

The openai package

npm install openai

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.usdf.fi/v1",
  apiKey: process.env.USDF_API_KEY,
});

const completion = await client.chat.completions.create({
  model: "<model>",
  messages: [{ role: "user", content: "Hello" }],
  max_tokens: 256,
});
console.log(completion.choices[0].message.content);

// The receipt is an extra field the SDK's types do not declare.
const { receipt } = completion as unknown as {
  receipt: { request_id: string; cost: { usdf: string } };
};
console.log(receipt.request_id, receipt.cost.usdf, "USDF");

createOpenAICompatible

npm install @ai-sdk/openai-compatible@3.0.54 ai@7.0.112

import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { generateText } from "ai";

const usdf = createOpenAICompatible({
  name: "usdf",
  baseURL: "https://api.usdf.fi/v1",
  apiKey: process.env.USDF_API_KEY,
});

const { text, response } = await generateText({
  model: usdf("<model>"),
  prompt: "Hello",
  maxOutputTokens: 256,
});
console.log(text, response.id);

export ANTHROPIC_BASE_URL=https://api.usdf.fi/v1
export ANTHROPIC_API_KEY="$USDF_API_KEY"

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.usdf.fi",
    "ANTHROPIC_AUTH_TOKEN": "sk_YOUR_KEY",
    "ANTHROPIC_MODEL": "MODEL_ID",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "MODEL_ID",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "MODEL_ID",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "MODEL_ID"
  }
}

export ANTHROPIC_BASE_URL="https://api.usdf.fi"
export ANTHROPIC_AUTH_TOKEN="sk_YOUR_KEY"
export ANTHROPIC_MODEL="MODEL_ID"
export ANTHROPIC_DEFAULT_OPUS_MODEL="MODEL_ID"
export ANTHROPIC_DEFAULT_SONNET_MODEL="MODEL_ID"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="MODEL_ID"
claude -p "Say hello in one word"

claude mcp add --transport http usdf https://api.usdf.fi/mcp --header "Authorization: Bearer sk_YOUR_KEY"

{
  "mcpServers": {
    "usdf": {
      "url": "https://api.usdf.fi/mcp",
      "headers": {
        "Authorization": "Bearer sk_YOUR_KEY"
      }
    }
  }
}

{
  "mcpServers": {
    "usdf": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote@0.14.3",
        "https://api.usdf.fi/mcp",
        "--header",
        "Authorization:${USDF_AUTH}"
      ],
      "env": {
        "USDF_AUTH": "Bearer sk_YOUR_KEY"
      }
    }
  }
}

Base URL   https://api.usdf.fi/v1
API key    sk_YOUR_KEY
Model      MODEL_ID
Docs       https://api.usdf.fi/llms.txt

ChatOpenAI

npm install @langchain/openai

import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "<model>",
  apiKey: process.env.USDF_API_KEY,
  maxTokens: 256,
  configuration: { baseURL: "https://api.usdf.fi/v1" },
});
const reply = await llm.invoke("Hello");
console.log(reply.content);

USDFChat

pip install usdf langchain-core eth-account

import os
from eth_account import Account
from usdf.langchain import USDFChat
wallet = Account.from_key(os.environ["PAYER_KEY"])
llm = USDFChat(model="<model>", wallet=wallet)  # or api_key="sk_..."
print(llm.invoke("Hello").content)

{
  "mcpServers": {
    "usdf": {
      "url": "https://api.usdf.fi/mcp",
      "headers": { "Authorization": "Bearer ${env:USDF_API_KEY}" }
    }
  }
}

{
  "mcpServers": {
    "usdf": {
      "command": "npx",
      "args": ["-y", "mcp-remote@0.14.3", "https://api.usdf.fi/mcp", "--header", "Authorization:${USDF_AUTH}"],
      "env": { "USDF_AUTH": "Bearer sk_..." }
    }
  }
}

The MCP TypeScript SDK

npm install @modelcontextprotocol/sdk@1.30.0

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(new URL("https://api.usdf.fi/mcp"), {
  requestInit: { headers: { Authorization: `Bearer ${process.env.USDF_API_KEY}` } },
});
const client = new Client({ name: "my-agent", version: "1.0.0" });
await client.connect(transport);

const { tools } = await client.listTools();
console.log(tools.map((t) => t.name));

const quote = await client.callTool({
  name: "quote",
  arguments: { model: "<model>", prompt: "Hello", max_tokens: 256 },
});
console.log(JSON.stringify(quote.structuredContent));

// With onprogress the SDK sends a progress token: the gateway reports progress
// as it works and allows the call up to 10 minutes. resetTimeoutOnProgress is
// what makes the client keep waiting.
const chat = await client.callTool(
  { name: "chat", arguments: { model: "<model>", messages: [{ role: "user", content: "Hello" }], max_tokens: 256 } },
  undefined,
  { timeout: 60_000, resetTimeoutOnProgress: true, onprogress: (p) => console.log("still generating", p.progress) },
);
console.log(JSON.stringify(chat.structuredContent));
await client.close();