Building AI-Powered Integrations

{
  "mcpServers": {
    "3plguys": {
      "type": "url",
      "url": "https://mcp.3plguys.com/mcp"
    }
  }
}

User: "Ship 5 units of product p_abc123 to Jane Doe at
       123 Main St, Austin TX 78701"

AI calls: create_pnp_draft({ warehouseId: "w_1" })
       → returns { id: "draft_xyz" }

AI calls: set_pnp_shipping_address({
            draftId: "draft_xyz",
            name: "Jane Doe",
            address1: "123 Main St",
            city: "Austin",
            state: "TX",
            zip: "78701"
          })

AI calls: set_pnp_items({
            draftId: "draft_xyz",
            items: [{ productId: "p_abc123", quantity: 5 }]
          })

AI calls: submit_pnp({ draftId: "draft_xyz" })
       → returns { id: "shp_final", status: "pending" }

AI: "Done! Shipment shp_final is now pending fulfillment."

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();
const TPL_BASE = "https://api.3plguys.com/v0";
const auth = { Authorization: `Bearer ${process.env.TPLGUYS_TOKEN}` };

const tools = [
  {
    name: "check_stock_levels",
    description: "Get current stock levels for all products with per-warehouse breakdown",
    input_schema: {
      type: "object",
      properties: {
        updatedSince: { type: "string", description: "ISO 8601 timestamp" },
        take: { type: "number", default: 50 },
        skip: { type: "number", default: 0 },
      },
    },
  },
  {
    name: "list_shipments",
    description: "List shipments filtered by type and status",
    input_schema: {
      type: "object",
      properties: {
        type: { type: "string", enum: ["outbound-pickpack", "outbound-spd", "inbound-container", "inbound-spd"] },
        status: { type: "string", enum: ["draft", "pending", "processing", "forwarded", "cancelled"] },
        take: { type: "number", default: 50 },
        skip: { type: "number", default: 0 },
      },
    },
  },
  {
    name: "create_pnp_draft",
    description: "Create a Pick & Pack shipment draft",
    input_schema: {
      type: "object",
      properties: {
        warehouseId: { type: "string" },
      },
      required: ["warehouseId"],
    },
  },
  {
    name: "set_pnp_shipping_address",
    description: "Set the shipping address on a PnP draft",
    input_schema: {
      type: "object",
      properties: {
        draftId: { type: "string" },
        name: { type: "string" },
        address1: { type: "string" },
        city: { type: "string" },
        state: { type: "string" },
        zip: { type: "string" },
      },
      required: ["draftId", "name", "address1", "city", "state", "zip"],
    },
  },
  {
    name: "set_pnp_items",
    description: "Set items on a PnP draft",
    input_schema: {
      type: "object",
      properties: {
        draftId: { type: "string" },
        items: {
          type: "array",
          items: {
            type: "object",
            properties: {
              productId: { type: "string" },
              quantity: { type: "number" },
            },
            required: ["productId", "quantity"],
          },
        },
      },
      required: ["draftId", "items"],
    },
  },
  {
    name: "submit_pnp",
    description: "Submit a PnP draft for fulfillment",
    input_schema: {
      type: "object",
      properties: {
        draftId: { type: "string" },
      },
      required: ["draftId"],
    },
  },
];

async function handleTool(name, input) {
  switch (name) {
    case "check_stock_levels": {
      const params = new URLSearchParams({
        take: String(input.take || 50),
        skip: String(input.skip || 0),
      });
      if (input.updatedSince) params.set("updatedSince", input.updatedSince);
      return fetch(`${TPL_BASE}/inventory/products/breakdown?${params}`, {
        headers: auth,
      }).then(r => r.json());
    }

    case "list_shipments": {
      const params = new URLSearchParams({
        take: String(input.take || 50),
        skip: String(input.skip || 0),
      });
      if (input.type) params.set("type", input.type);
      if (input.status) params.set("status", input.status);
      return fetch(`${TPL_BASE}/shipments?${params}`, {
        headers: auth,
      }).then(r => r.json());
    }

    case "create_pnp_draft":
      return fetch(`${TPL_BASE}/shipments/pnp`, {
        method: "POST",
        headers: { ...auth, "Content-Type": "application/json" },
        body: JSON.stringify({ warehouseId: input.warehouseId }),
      }).then(r => r.json());

    case "set_pnp_shipping_address": {
      const { draftId, ...address } = input;
      return fetch(`${TPL_BASE}/shipments/pnp/${draftId}/shipping-address`, {
        method: "PUT",
        headers: { ...auth, "Content-Type": "application/json" },
        body: JSON.stringify(address),
      }).then(r => r.json());
    }

    case "set_pnp_items":
      return fetch(`${TPL_BASE}/shipments/pnp/${input.draftId}/items`, {
        method: "PUT",
        headers: { ...auth, "Content-Type": "application/json" },
        body: JSON.stringify({ items: input.items }),
      }).then(r => r.json());

    case "submit_pnp":
      return fetch(`${TPL_BASE}/shipments/pnp/${input.draftId}/submit`, {
        method: "POST",
        headers: auth,
      }).then(r => r.json());
  }
}

// Run the agent loop
async function runAgent(userMessage) {
  const messages = [{ role: "user", content: userMessage }];

  while (true) {
    const response = await client.messages.create({
      model: "claude-sonnet-4-20250514",
      max_tokens: 4096,
      tools,
      messages,
      system: "You are a warehouse operations assistant for 3PLGuys. Help manage inventory, shipments, and fulfillment.",
    });

    // If the model wants to use tools, execute them
    if (response.stop_reason === "tool_use") {
      const toolUse = response.content.find(c => c.type === "tool_use");
      const result = await handleTool(toolUse.name, toolUse.input);

      messages.push({ role: "assistant", content: response.content });
      messages.push({
        role: "user",
        content: [{
          type: "tool_result",
          tool_use_id: toolUse.id,
          content: JSON.stringify(result),
        }],
      });
    } else {
      // Final text response
      return response.content.find(c => c.type === "text")?.text;
    }
  }
}

// Example usage
const answer = await runAgent(
  "Check our inventory levels and tell me which products are running low"
);
console.log(answer);

async function smartInventoryCheck() {
  const levels = await fetch(
    `${TPL_BASE}/inventory/products/breakdown?take=50`,
    { headers: auth }
  ).then(r => r.json());

  const shipments = await fetch(
    `${TPL_BASE}/shipments?type=outbound-pickpack&status=pending&take=50`,
    { headers: auth }
  ).then(r => r.json());

  // Ask AI to analyze the situation
  const analysis = await runAgent(
    `Here's our current inventory:\n${JSON.stringify(levels)}\n\n` +
    `And pending outbound orders:\n${JSON.stringify(shipments)}\n\n` +
    `Identify any products at risk of stockout considering pending orders. ` +
    `Flag anything that needs immediate attention.`
  );

  if (analysis.includes("immediate attention") || analysis.includes("stockout")) {
    await sendSlackAlert(analysis);
  }
}

curl https://api.3plguys.com/openapi.json -o openapi.json

import { parse } from "yaml";
import fs from "fs";

const spec = JSON.parse(fs.readFileSync("openapi.json", "utf-8"));

// Extract endpoints as tool definitions
const tools = Object.entries(spec.paths).flatMap(([path, methods]) =>
  Object.entries(methods).map(([method, details]) => ({
    name: `${method}_${path.replace(/\//g, "_").replace(/[{}:]/g, "")}`,
    description: details.summary || details.description,
    method: method.toUpperCase(),
    path,
    parameters: details.parameters || [],
  }))
);

console.log(`Generated ${tools.length} tools from OpenAPI spec`);

curl https://developer.3plguys.com/llms.txt