Fabric Documentation

npm install @usefabric/mcp

import { FabricServer } from '@usefabric/mcp'

const fabric = new FabricServer({
  apiKey: process.env.FABRIC_KEY,
  budget: '$5/day',           // Daily spend limit
  trustThreshold: 0.8,       // Min trust score (0-1)
  chain: 'base',              // Payment chain
  fallbackEnabled: true,     // Auto-retry on failure
})

{
  "mcpServers": {
    "fabric": {
      "command": "npx",
      "args": ["@usefabric/mcp"],
      "env": {
        "FABRIC_KEY": "your-api-key"
      }
    }
  }
}

// Your agent can now say things like:
"Use Fabric to find an image generation service and generate a logo"
"Check my remaining budget on Fabric"
"Evaluate the trust score of provider 0x1234..."

Your Agent (Claude, Cursor, LangChain, custom)
    │
    ├── MCP protocol  (6 tools: discover, route, evaluate, budget, feedback, favorites)
    ├── REST API      (22 endpoints, /v1/*)
    └── SDKs          (TypeScript + Python)
    │
    ▼
Fabric Gateway (Elysia + Bun)
    ├── Auth              → API key validation + plan enforcement
    ├── Rate Limiter       → sliding window (Redis sorted sets)
    ├── Usage Tracker      → per-request metering + overage
    ├── Trust Scorer       → live scoring + time-decay + circuit breaker
    ├── Provider Selector  → composite ranking + fallback
    ├── Route Executor     → x402 → direct → mock (3-tier)
    ├── Budget Engine      → per-agent/task limits + daily/weekly/monthly reset
    └── Billing           → Stripe subscriptions + overage + invoices
    │
    ▼
Base L2
    ├── FabricRegistry.sol  → ERC-8004 agent/provider registry
    ├── FabricIdentity.sol  → ERC-721 identity NFTs
    └── USDC transfers      → x402 payment settlement

{
  "providers": [
    {
      "agentId": "0x1a2b...3c4d",
      "name": "PixelForge",
      "capability": "image-generation",
      "trustScore": 0.94,
      "price": "$0.02",
      "uptime": 0.998,
      "totalReviews": 1247,
      "endpoint": "https://pixelforge.ai/v1"
    },
    // ...
  ],
  "totalFound": 12,
  "filtered": 4 // below trust threshold
}

// Agent calls route with a task
fabric.route({
  capability: "image-generation",
  input: { prompt: "A blue octopus reading a newspaper" },
  priority: "quality"
})

// Returns
{
  "result": { url: "https://...", format: "png" },
  "provider": "PixelForge",
  "cost": "$0.02",
  "latency": "240ms",
  "txHash": "0xabc...",
  "trustScore": 0.94,
  "fallbackUsed": false
}

{
  "agentId": "0x1a2b...3c4d",
  "name": "PixelForge",
  "overallTrust": 0.94,
  "breakdown": {
    "uptime": 0.998,
    "quality": 0.92,
    "responseTime": 0.88,
    "reviewerCredibility": 0.96,
    "priceEfficiency": 0.91
  },
  "totalFeedback": 1247,
  "registeredSince": "2026-01-30",
  "capabilities": ["image-generation", "image-editing"],
  "x402Enabled": true
}

// Anyone can register
registry.registerAgent(
  keccak256("prov_flux_001"),      // bytes32 agentId
  "https://flux.ai/v1/generate",  // endpoint
  "image-generation",             // category
  "Flux Pro"                       // name
);

// Operator batches reputation updates
registry.batchUpdateReputation(
  agentIds,       // bytes32[]
  scores,         // uint256[] (×1000, e.g. 4500 = 4.5)
  interactions    // uint256[] (accumulates)
);

// Read providers by category (paginated)
Agent[] memory agents = registry.getAgentsByCategory("image-generation", 0, 10);

// Operator mints identity NFT
uint256 tokenId = identity.mint(
  agentWallet,                     // address to
  "Flux Pro",                      // agentName
  keccak256("prov_flux_001")       // registryId (must match registry)
);

// Read agent data from NFT
(string name, bytes32 regId, uint256 createdAt) = identity.getAgentData(tokenId);

# Deploy both contracts
forge script script/Deploy.s.sol:DeployFabric \
  --rpc-url $BASE_SEPOLIA_RPC_URL \
  --private-key $PRIVATE_KEY \
  --broadcast --verify

# Seed 5 test providers
forge script script/Deploy.s.sol:SeedProviders --rpc-url $BASE_SEPOLIA_RPC_URL --broadcast

# Mint identity NFTs
forge script script/Deploy.s.sol:MintIdentities --rpc-url $BASE_SEPOLIA_RPC_URL --broadcast

Browser (site)          Fabric Gateway            Base L2
──────────────          ──────────────            ────────
registerTool() ───────► Index tool contract
                        Compute trust score
                        
Agent calls tool ──────► Verify trust ≥ threshold
                        Settle x402 payment ──────► USDC transfer
                        Proxy to origin     ◄────── Confirmation
               ◄─────── Return result + receipt

npm install @usefabric/webmcp

import { FabricWebMCP } from '@usefabric/webmcp'

const fabric = new FabricWebMCP({
  apiKey: process.env.FABRIC_KEY,
  gateway: 'https://fabric-gateway.fly.dev',
})

// Register a tool — bridges navigator.modelContext with Fabric trust+payment
fabric.registerTool({
  name: 'searchProducts',
  description: 'Search the product catalog',
  inputSchema: {
    type: 'object',
    properties: {
      query: { type: 'string' },
      maxResults: { type: 'number' },
    },
    required: ['query'],
  },
  category: 'ecommerce',
  pricePerCall: 0.01,                // $0.01 per call — settled via x402
  async execute(params) {
    return await productSearch(params.query)
  },
})

// Tools auto-sync to Fabric on registration

const result = await fabric.execute(
  'searchProducts',
  { query: 'running shoes' },
  agentId
)
// result.payment.settled === true
// result.trust.score === 0.92

const result = await fabric.executeLocal(
  'searchProducts',
  { query: 'running shoes' },
  agentId
)
// result.local === true — executed in-browser

import { FabricClient } from '@fabric/sdk'

const fabric = new FabricClient({ apiKey: 'fab_...', baseUrl: 'https://api.usefabric.ai' })

// Discover providers
const providers = await fabric.discover({ category: 'image-generation', minTrust: 0.8 })

// Route (discover → score → pay → return)
const result = await fabric.route({
  capability: 'image-generation',
  input: { prompt: 'A sunset over the ocean' },
  priority: 'quality'
})

// Check budget
const budget = await fabric.getBudget()

from fabric_sdk import FabricClient

fabric = FabricClient(api_key="fab_...")

# Async discover
providers = await fabric.discover(category="translation", min_trust=0.7)

# Sync route
result = fabric.route_sync(
    capability="translation",
    input={"text": "Hello world", "target": "es"}
)

new FabricServer({
  // Required
  apiKey: "fab_...",

  // Trust
  trustThreshold: 0.8,      // 0-1, min trust score
  priority: "quality",       // quality | speed | cost
  fallbackEnabled: true,    // auto-retry next provider
  maxFallbacks: 3,          // max retry attempts

  // Payments
  chain: "base",             // payment chain
  token: "USDC",             // payment token

  // Budgets
  budget: "$5/day",          // daily limit
  maxPerRequest: "$0.50",   // per-call limit
  maxPerTask: "$2.00",      // per-task limit

  // Feedback
  autoFeedback: true,       // post feedback after route
  feedbackDelay: 5000,      // ms delay before posting
})

# Start the full stack
docker compose -f docker-compose.prod.yml up -d

# Services: gateway, postgres, redis, prometheus, grafana
# Gateway: 512M memory, non-root user, health check every 15s
# Grafana dashboard: 8 panels (request rate, error rate, p99 latency, memory)

GET /healthz  → shallow (for load balancers)
GET /ready    → readiness (DB healthy, Redis optional) — 503 if not ready
GET /health   → deep (postgres latency, redis latency, memory, uptime)