Building a Custom Agent

mkdir my-frontdesk-agent && cd my-frontdesk-agent
npm init -y
npm install @modelcontextprotocol/sdk @anthropic-ai/sdk @frontdeskos/mcp-server

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

export async function createMCPClient() {
  const transport = new StdioClientTransport({
    command: "npx",
    args: ["@frontdeskos/mcp-server"],
    env: {
      FRONTDESK_API_KEY: process.env.FRONTDESK_API_KEY!,
      FRONTDESK_WORKSPACE_ID: process.env.FRONTDESK_WORKSPACE_ID!,
    },
  });

  const client = new Client(
    { name: "my-frontdesk-agent", version: "1.0.0" },
    { capabilities: {} }
  );

  await client.connect(transport);

  // Discover available tools
  const { tools } = await client.listTools();
  console.log(`Connected to FrontDeskOS with ${tools.length} tools`);

  // Read resources for context
  const { resources } = await client.listResources();
  console.log(`Available resources: ${resources.map(r => r.uri).join(", ")}`);

  return client;
}

import Anthropic from "@anthropic-ai/sdk";
import { createMCPClient } from "./mcp-client.js";

const anthropic = new Anthropic();

async function main() {
  const mcp = await createMCPClient();

  // Get tools and convert to Anthropic's format
  const { tools: mcpTools } = await mcp.listTools();
  const tools = mcpTools.map((tool) => ({
    name: tool.name,
    description: tool.description || "",
    input_schema: tool.inputSchema as Anthropic.Tool["input_schema"],
  }));

  // Load business context from resources
  const businessInfo = await mcp.readResource({
    uri: "frontdesk://business-info",
  });
  const staffDir = await mcp.readResource({
    uri: "frontdesk://staff-directory",
  });

  const systemPrompt = `You are an AI assistant for front desk management.
You have access to FrontDeskOS tools to manage calls, appointments, leads, and analytics.

Business context:
${businessInfo.contents[0].text}

Staff directory:
${staffDir.contents[0].text}

Use the available tools to help the user manage their front desk operations.
Always confirm important actions before executing them.`;

  // Conversation loop
  const messages: Anthropic.MessageParam[] = [];

  async function chat(userMessage: string): Promise<string> {
    messages.push({ role: "user", content: userMessage });

    let response = await anthropic.messages.create({
      model: "claude-sonnet-4-6",
      max_tokens: 4096,
      system: systemPrompt,
      tools,
      messages,
    });

    // Handle tool use loop
    while (response.stop_reason === "tool_use") {
      const assistantMessage = response.content;
      messages.push({ role: "assistant", content: assistantMessage });

      const toolResults: Anthropic.ToolResultBlockParam[] = [];

      for (const block of assistantMessage) {
        if (block.type === "tool_use") {
          console.log(`Calling tool: ${block.name}`);
          const result = await mcp.callTool({
            name: block.name,
            arguments: block.input as Record<string, unknown>,
          });

          toolResults.push({
            type: "tool_result",
            tool_use_id: block.id,
            content: JSON.stringify(result.content),
          });
        }
      }

      messages.push({ role: "user", content: toolResults });

      response = await anthropic.messages.create({
        model: "claude-sonnet-4-6",
        max_tokens: 4096,
        system: systemPrompt,
        tools,
        messages,
      });
    }

    // Extract text response
    const textBlocks = response.content.filter(
      (b) => b.type === "text"
    );
    const reply = textBlocks.map((b) => b.text).join("\n");
    messages.push({ role: "assistant", content: reply });

    return reply;
  }

  return { chat, close: () => mcp.close() };
}

// Run the agent
const agent = await main();
const reply = await agent.chat("What calls did we get today?");
console.log(reply);

import express from "express";
import { main as createAgent } from "./agent.js";

const app = express();
app.use(express.json());

// Store agent sessions
const sessions = new Map();

app.post("/api/chat", async (req, res) => {
  const { session_id, message } = req.body;

  // Get or create agent session
  if (!sessions.has(session_id)) {
    sessions.set(session_id, await createAgent());
  }

  const agent = sessions.get(session_id);
  const reply = await agent.chat(message);

  res.json({ reply });
});

app.listen(3000, () => {
  console.log("Custom FrontDesk agent running on :3000");
});