Examples

Paste one example into the tool editor. Add its listed parameters and secrets. Database examples need your own tables and data. PostgreSQL examples use these secrets: DB_HOST, DB_PORT, DB_NAME, DB_USER, DB_PASSWORD. Set DB_PORT to 5432 unless your database uses another allowed port.

GET with authentication

Parameters: repo (required string, such as octocat/Hello-World). Secret: GITHUB_TOKEN.

const response = await sdk.http({
  url: `https://api.github.com/repos/${params.repo}`,
  headers: {
    Authorization: `Bearer ${env.GITHUB_TOKEN}`,
    "User-Agent": "TryMCP-Tool",
  },
});

if (!response.ok) {
  throw new Error(`GitHub returned ${response.status}`);
}

const repo = response.json();

return {
  name: repo.full_name,
  stars: repo.stargazers_count,
  forks: repo.forks_count,
  language: repo.language,
  topics: repo.topics,
};

See the GitHub repository API for token access requirements.

POST a JSON body

Send an email with SendGrid. Use a verified sender in SENDER_EMAIL. Parameters: to, subject, body (required strings). Secrets: SENDGRID_API_KEY, SENDER_EMAIL.

const response = await sdk.http({
  method: "POST",
  url: "https://api.sendgrid.com/v3/mail/send",
  headers: { Authorization: `Bearer ${env.SENDGRID_API_KEY}` },
  body: {
    personalizations: [{ to: [{ email: params.to }] }],
    from: { email: env.SENDER_EMAIL },
    subject: params.subject,
    content: [{ type: "text/plain", value: params.body }],
  },
});

if (!response.ok) {
  throw new Error(`SendGrid returned ${response.status}`);
}

return { status: response.status, accepted: true };

An accepted request does not confirm delivery. See SendGrid Mail Send.

Webhook relay

Parameters: event (required string), payload (required object). Secrets: WEBHOOK_URL, WEBHOOK_SECRET. Use your HTTPS webhook URL. Its receiver must accept this body and the X-Webhook-Secret header.

const response = await sdk.http({
  method: "POST",
  url: env.WEBHOOK_URL,
  headers: { "X-Webhook-Secret": env.WEBHOOK_SECRET },
  body: {
    event: params.event,
    data: params.payload,
    timestamp: new Date().toISOString(),
  },
});

return { status: response.status, accepted: response.ok };

Select with filters

Parameters: userId (required string), status (optional string). Use the PostgreSQL secrets listed above.

const db = await sdk.db({
  type: "pg",
  connection: {
    host: env.DB_HOST,
    port: Number(env.DB_PORT),
    database: env.DB_NAME,
    user: env.DB_USER,
    password: env.DB_PASSWORD,
  },
});

try {
  const filters = { user_id: params.userId };

  if (params.status) {
    filters.status = params.status;
  }

  const orders = await db.select("orders", filters);

  return { count: orders.length, orders };
} finally {
  await db.destroy();
}

Insert a record

Parameters: name, email (required strings), role (optional string). Use the PostgreSQL secrets. The users table needs id, name, email, role, and created_at columns.

const db = await sdk.db({
  type: "pg",
  connection: {
    host: env.DB_HOST,
    port: Number(env.DB_PORT),
    database: env.DB_NAME,
    user: env.DB_USER,
    password: env.DB_PASSWORD,
  },
});

try {
  const records = await db.query(
    "INSERT INTO users (name, email, role, created_at) VALUES (?, ?, ?, ?) RETURNING id",
    [params.name, params.email, params.role ?? "member", new Date().toISOString()],
  );

  return { id: records[0].id };
} finally {
  await db.destroy();
}

SQL with pagination

Parameters: category (required string), page, pageSize (optional numbers). Use the PostgreSQL secrets. This query uses products and categories tables.

const page = params.page ?? 1;
const pageSize = params.pageSize ?? 20;

if (!Number.isInteger(page) || page < 1 || !Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100) {
  throw new Error("Use a positive page and a pageSize from 1 to 100");
}

const db = await sdk.db({
  type: "pg",
  connection: {
    host: env.DB_HOST,
    port: Number(env.DB_PORT),
    database: env.DB_NAME,
    user: env.DB_USER,
    password: env.DB_PASSWORD,
  },
});

try {
  const products = await db.query(
    "SELECT p.id, p.name, p.price, p.stock FROM products p JOIN categories c ON c.id = p.category_id WHERE c.slug = ? ORDER BY p.id LIMIT ? OFFSET ?",
    [params.category, pageSize, (page - 1) * pageSize],
  );
  const counts = await db.query(
    "SELECT COUNT(*) AS total FROM products p JOIN categories c ON c.id = p.category_id WHERE c.slug = ?",
    [params.category],
  );

  return { page, pageSize, total: Number(counts[0].total), products };
} finally {
  await db.destroy();
}

MySQL query

Parameter: email (required string). Secrets: MYSQL_HOST, MYSQL_PORT, MYSQL_DB, MYSQL_USER, MYSQL_PASSWORD.

const db = await sdk.db({
  type: "mysql2",
  connection: {
    host: env.MYSQL_HOST,
    port: Number(env.MYSQL_PORT || 3306),
    database: env.MYSQL_DB,
    user: env.MYSQL_USER,
    password: env.MYSQL_PASSWORD,
  },
});

try {
  const users = await db.select("users", { email: params.email });

  return { found: users.length > 0, user: users[0] ?? null };
} finally {
  await db.destroy();
}

Group and summarize data

Parameter: userId (required string). Use the PostgreSQL secrets. Order rows need status, created_at, and numeric amount values.

const db = await sdk.db({
  type: "pg",
  connection: {
    host: env.DB_HOST,
    port: Number(env.DB_PORT),
    database: env.DB_NAME,
    user: env.DB_USER,
    password: env.DB_PASSWORD,
  },
});

try {
  const orders = await db.select("orders", { user_id: params.userId });
  const lodash = sdk.lodash;

  return {
    totalOrders: orders.length,
    totalSpent: lodash.sumBy(orders, order => Number(order.amount)),
    statusCounts: lodash.countBy(orders, "status"),
    recentOrders: lodash.orderBy(orders, ["created_at"], ["desc"]).slice(0, 5),
  };
} finally {
  await db.destroy();
}

Remove duplicates and filter

Parameter: query (required string). Secrets: API_URL, API_KEY. Set API_URL to your HTTPS API base URL. This example expects a /search endpoint that returns a results array.

const response = await sdk.http({
  url: `${env.API_URL}/search?q=${encodeURIComponent(params.query)}`,
  headers: { Authorization: `Bearer ${env.API_KEY}` },
});

if (!response.ok) {
  throw new Error(`Search returned ${response.status}`);
}

const lodash = sdk.lodash;
const unique = lodash.uniqBy(response.json().results, "id");
const active = unique.filter(item => item.status === "active");
const items = active.map(item => lodash.pick(item, ["id", "name", "category", "score"]));
const results = lodash.orderBy(items, ["score"], ["desc"]).slice(0, 10);

return { count: results.length, results };

API call and database write

Parameter: repo (required string). Secrets: GITHUB_TOKEN and the PostgreSQL secrets. The repo_snapshots table needs id, repo_name, stars, forks, language, and captured_at columns.

const response = await sdk.http({
  url: `https://api.github.com/repos/${params.repo}`,
  headers: {
    Authorization: `Bearer ${env.GITHUB_TOKEN}`,
    "User-Agent": "TryMCP-Tool",
  },
});

if (!response.ok) {
  throw new Error(`GitHub returned ${response.status}`);
}

const repo = response.json();
const db = await sdk.db({
  type: "pg",
  connection: {
    host: env.DB_HOST,
    port: Number(env.DB_PORT),
    database: env.DB_NAME,
    user: env.DB_USER,
    password: env.DB_PASSWORD,
  },
});

try {
  const records = await db.query(
    "INSERT INTO repo_snapshots (repo_name, stars, forks, language, captured_at) VALUES (?, ?, ?, ?, ?) RETURNING id",
    [repo.full_name, repo.stargazers_count, repo.forks_count, repo.language, new Date().toISOString()],
  );

  return { repo: repo.full_name, stars: repo.stargazers_count, snapshotId: records[0].id };
} finally {
  await db.destroy();
}

Handle errors and enrich a result

Parameter: userId (required string). Secrets: API_URL, API_KEY, and the PostgreSQL secrets. Set API_URL to your HTTPS API base URL. Its /users/:id endpoint must return a user with id, name, and email.

const response = await sdk.http({
  url: `${env.API_URL}/users/${encodeURIComponent(params.userId)}`,
  headers: { Authorization: `Bearer ${env.API_KEY}` },
});

if (response.status === 404) {
  return { found: false };
}

if (!response.ok) {
  console.error("User lookup failed", response.status);
  throw new Error(`API returned ${response.status}`);
}

const user = response.json();
const db = await sdk.db({
  type: "pg",
  connection: {
    host: env.DB_HOST,
    port: Number(env.DB_PORT),
    database: env.DB_NAME,
    user: env.DB_USER,
    password: env.DB_PASSWORD,
  },
});

try {
  const orders = await db.select("orders", { user_id: params.userId });

  return {
    found: true,
    user: { id: user.id, name: user.name, email: user.email },
    stats: {
      totalOrders: orders.length,
      totalSpent: sdk.lodash.sumBy(orders, order => Number(order.amount)),
      lastOrder: sdk.lodash.maxBy(orders, "created_at")?.created_at ?? null,
    },
  };
} finally {
  await db.destroy();
}

Start here

Build

Check

Connect

GET with authentication

POST a JSON body

Webhook relay

Select with filters

Insert a record

MySQL query

Group and summarize data

Remove duplicates and filter

API call and database write

Handle errors and enrich a result

​GET with authentication

​POST a JSON body

​Webhook relay

​Select with filters

​Insert a record

​SQL with pagination

​MySQL query

​Group and summarize data

​Remove duplicates and filter

​API call and database write

​Handle errors and enrich a result

GET with authentication

POST a JSON body

Webhook relay

Select with filters

Insert a record

SQL with pagination

MySQL query

Group and summarize data

Remove duplicates and filter

API call and database write

Handle errors and enrich a result