@lendwise/mcp 0.1.0

package/dist/core/tools/optimize-allocation.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const optimizeAllocationArgs: {
+    amountUsd: z.ZodNumber;
+    productIds: z.ZodArray<z.ZodString>;
+    diversification: z.ZodDefault<z.ZodNumber>;
+};
+/**
+ * Allocate `amountUsd` across the given markets via the solver.
+ *
+ * The solver speaks positions, not ids: we hand it `apy[]` and it hands back
+ * `vault_index`. Both directions run off the single array built by
+ * `buildApyVector`, so the index it returns cannot drift from the product it
+ * meant. Getting this wrong would attribute real money to the wrong market and
+ * nothing downstream would notice — hence the unit tests.
+ */
+export declare function optimizeAllocation(raw: unknown): Promise<{
+    error: string;
+    missing: string[];
+    disclaimer: string;
+} | {
+    disclaimer: string;
+    excluded?: {
+        productIds: string[];
+        reason: string;
+    } | undefined;
+    amountUsd: number;
+    diversification: number;
+    allocations: {
+        productId: string;
+        amountUsd: number;
+        allocationPercent: number;
+        netApy: number;
+    }[];
+    blendedNetApy: number;
+    projected: {
+        months: number;
+        yieldUsd: number;
+        caveat: string;
+    };
+    error?: undefined;
+    missing?: undefined;
+}>;

package/dist/core/tools/optimize-allocation.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { NOT_ADVICE } from '../config.js';
+import { gql } from '../graphql/client.js';
+import { LATEST_SUPPLY_BY_PRODUCTS, } from '../graphql/queries.js';
+import { blendedApy, buildApyVector, mapAllocations, optimizeVaults, } from '../optimizer.js';
+import { finite } from './shared.js';
+export const optimizeAllocationArgs = {
+    amountUsd: z
+        .number()
+        .positive()
+        .describe('Total amount to allocate, in USD.'),
+    productIds: z
+        .array(z.string().min(1))
+        .min(2)
+        .max(20)
+        .describe('Markets to allocate across, from find_best_markets. Order is not ' +
+        'significant to you, but is preserved internally.'),
+    diversification: z
+        .number()
+        .min(0)
+        .max(100)
+        .default(80)
+        .describe('Target diversification score. 80 = highly diversified, 0 = concentrate ' +
+        'everything in the highest yield.'),
+};
+const Args = z.object(optimizeAllocationArgs);
+/** Months of projected yield to report — matches the 6-month horizon the tool is for. */
+const PROJECTION_MONTHS = 6;
+/**
+ * Allocate `amountUsd` across the given markets via the solver.
+ *
+ * The solver speaks positions, not ids: we hand it `apy[]` and it hands back
+ * `vault_index`. Both directions run off the single array built by
+ * `buildApyVector`, so the index it returns cannot drift from the product it
+ * meant. Getting this wrong would attribute real money to the wrong market and
+ * nothing downstream would notice — hence the unit tests.
+ */
+export async function optimizeAllocation(raw) {
+    const { amountUsd, productIds, diversification } = Args.parse(raw);
+    // De-duplicate: the same product twice would occupy two positions and let the
+    // solver "diversify" across what is really one market.
+    const unique = [...new Set(productIds)];
+    // ONE request for the whole batch, via the server-side productIds filter. A
+    // request per product would spend up to 20 of the caller's 60 req/min budget
+    // on a single optimize_allocation, and rate-limit the agent mid-flow.
+    const data = await gql(LATEST_SUPPLY_BY_PRODUCTS, { productIds: unique, first: unique.length });
+    const latestApyByProduct = new Map();
+    for (const row of data.latestSupplyApy.items) {
+        const net = finite(row.apy.net);
+        if (net !== null)
+            latestApyByProduct.set(row.productId, net);
+    }
+    const { apys, found, missing } = buildApyVector(unique, latestApyByProduct);
+    if (found.length < 2) {
+        return {
+            error: 'Need at least 2 markets with a current APY to allocate across. ' +
+                `Only ${found.length} of ${unique.length} had a usable snapshot.`,
+            missing,
+            disclaimer: NOT_ADVICE,
+        };
+    }
+    const response = await optimizeVaults(apys, diversification);
+    // `found` is the array the apys were built from, so vault_index indexes it.
+    const allocations = mapAllocations(found, apys, response.allocations, amountUsd).filter((a) => a.amountUsd > 0);
+    const blended = blendedApy(allocations);
+    return {
+        amountUsd,
+        diversification: response.resulting_diversification,
+        allocations: allocations
+            .sort((a, b) => b.amountUsd - a.amountUsd)
+            .map((a) => ({
+            productId: a.productId,
+            amountUsd: Number(a.amountUsd.toFixed(2)),
+            allocationPercent: a.allocationPercent,
+            netApy: a.apy,
+        })),
+        blendedNetApy: blended,
+        projected: {
+            months: PROJECTION_MONTHS,
+            // Simple pro-rata of the annual rate. The APYs are variable, so compounding
+            // precision here would be false precision.
+            yieldUsd: Number((amountUsd * blended * (PROJECTION_MONTHS / 12)).toFixed(2)),
+            caveat: 'Projection assumes today’s APYs hold for the whole period. They will ' +
+                'not — check get_market_history for how much each one actually moves.',
+        },
+        ...(missing.length > 0
+            ? {
+                excluded: {
+                    productIds: missing,
+                    reason: 'No current APY snapshot; excluded rather than assumed to be zero.',
+                },
+            }
+            : {}),
+        disclaimer: NOT_ADVICE,
+    };
+}

package/dist/core/tools/shared.d.ts

@@ -0,0 +1,28 @@
+import type { SnapshotRow } from '../graphql/queries.js';
+/** Coerce a non-finite number to null. Never let NaN out of a tool. */
+export declare function finite(v: number | null | undefined): number | null;
+export interface DescribedMarket {
+    productId: string;
+    asset: string;
+    chain: string;
+    chainId: number;
+    protocol: string;
+    market: string;
+    apy: {
+        net: number | null;
+        base: number | null;
+        rewards: number | null;
+        fees: number | null;
+    };
+    tvlUsd: number | null;
+    utilizationRate: number | null;
+    /** Snapshot time — every response says how fresh it is. */
+    asOf: string;
+    quality: {
+        status: string;
+        slots: string;
+        reliable: boolean;
+    };
+}
+export declare function describeRow(row: SnapshotRow): DescribedMarket;
+export declare function isUnreliable(m: DescribedMarket): boolean;

package/dist/core/tools/shared.js

@@ -0,0 +1,41 @@
+/** Coerce a non-finite number to null. Never let NaN out of a tool. */
+export function finite(v) {
+    return typeof v === 'number' && Number.isFinite(v) ? v : null;
+}
+/**
+ * A row's data quality. `quality.count` is how many 10-minute slots of the
+ * current hour have landed; below half the expected count the hour's average is
+ * built on too little and is flagged rather than silently returned as fact.
+ */
+function reliability(row) {
+    const { count, expectedCount, status } = row.quality;
+    const completeness = expectedCount > 0 ? count / expectedCount : 0;
+    return {
+        status,
+        slots: `${count}/${expectedCount}`,
+        reliable: completeness >= 0.5,
+    };
+}
+export function describeRow(row) {
+    return {
+        productId: row.productId,
+        asset: row.asset,
+        chain: row.product?.protocol.chain.name ?? String(row.chainId),
+        chainId: row.chainId,
+        protocol: row.product?.protocol.provider ?? 'unknown',
+        market: row.product?.protocol.name ?? 'unknown',
+        apy: {
+            net: finite(row.apy.net),
+            base: finite(row.apy.base),
+            rewards: finite(row.apy.rewards),
+            fees: finite(row.apy.fees),
+        },
+        tvlUsd: finite(row.market.supplyAssetsUsd),
+        utilizationRate: finite(row.market.utilizationRate),
+        asOf: row.hour,
+        quality: reliability(row),
+    };
+}
+export function isUnreliable(m) {
+    return !m.quality.reliable;
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@lendwise/mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Lendwise — compare DeFi supply/borrow markets across Aave, Morpho and Compound on 27 standardized chains.",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "bin": {
+    "lendwise-mcp": "./dist/bin/stdio.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.22.0",
+    "mcp-handler": "^1.0.2",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^24.9.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.7"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit -p tsconfig.check.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "start": "node dist/bin/stdio.js"
+  }
+}