Expose your tools over MCP

import { McpToolSource } from '@aiconnect/core';

const tools = new McpToolSource('/api/mcp', 'TaamTaam');

import { finalAnswer, runConversation } from '@aiconnect/core';

const added = await runConversation({
  session: state.session,
  tools,
  messages: [{ role: 'system', content: SYSTEM_PROMPT }, { role: 'user', content: question }],
  maxSteps: 4,
  onToolCall: (call) => console.log('calling', call.name, call.arguments),
  onToolResult: (call, result) => console.log(call.name, 'returned', result.length, 'characters'),
});
const answer = finalAnswer(added)?.content;

import { McpToolSource } from '@aiconnect/core';
import { createOpenAI } from '@ai-sdk/openai';
import { jsonSchema, stepCountIs, streamText, tool } from 'ai';

const source = new McpToolSource('/api/mcp', 'TaamTaam');
const openai = createOpenAI({ apiKey: aiconnect.sdkOptions.apiKey, fetch: aiconnect.fetch });

const tools = Object.fromEntries((await source.listTools()).map((definition) => [definition.name, tool({
  description: definition.description,
  inputSchema: jsonSchema(definition.inputSchema),
  execute: (args) => source.callTool(definition.name, args),
})]));
const result = streamText({
  model: openai('gpt-6-luna'), system: SYSTEM_PROMPT, prompt: question, tools, stopWhen: stepCountIs(4),
});

const mcpRouter = require('express').Router()
const { StreamableHTTPServerTransport } = require('@modelcontextprotocol/sdk/server/streamableHttp.js')
const { buildCatalogMcpServer } = require('../services/restaurantCatalog/catalogMcpServer')
// Taamtaam's own helpers: a rate limiter keyed by the visitor's address, and its logger.
const { createRateLimiter } = require('../utils/rateLimit')
const { clientIpKey } = require('../utils/clientIp')
const logger = require('../utils/logger')

const catalogLimiter = createRateLimiter({
  windowMs: 60 * 1000,
  max: 60,
  keyFn: clientIpKey('mcp-catalog'),
  message: 'Too many catalog requests from this connection. Please try again in a minute.'
})

mcpRouter.post('/catalog', catalogLimiter, async (request, response) => {
  const server = buildCatalogMcpServer()
  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true })
  response.on('close', () => {
    transport.close()
    server.close()
  })
  try {
    await server.connect(transport)
    await transport.handleRequest(request, response, request.body)
  } catch (error) {
    logger.error('MCP catalog request failed:', error)
    if (!response.headersSent) {
      response.status(500).json({ error: 'MCP request failed' })
    }
  }
})

// The stateless transport serves POST only.
const methodNotAllowed = (request, response) => response.status(405).json({ error: 'Method not allowed' })
mcpRouter.get('/catalog', methodNotAllowed)
mcpRouter.delete('/catalog', methodNotAllowed)

module.exports = mcpRouter

const { z } = require('zod')
const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js')
const { FEATURE_FIELDS, MAX_LIMIT } = require('./catalogQuery')
const catalog = require('./index')
const Restaurant = require('../../models/restaurant')

const READ_ONLY = { readOnlyHint: true, openWorldHint: false }
const jsonResult = (value) => ({ content: [{ type: 'text', text: JSON.stringify(value) }] })

const registerFilters = (server) => server.registerTool('list_filters', {
  title: 'Search filters',
  description: 'The values search_restaurants accepts: cities, cuisines, ambiances, styles, kashrut '
    + 'certifications, features and the price scale.',
  inputSchema: {},
  annotations: READ_ONLY
}, async () => jsonResult(await catalog.listFacets()))

const buildCatalogMcpServer = () => {
  const server = new McpServer({ name: 'taamtaam', version: '1.0.0' })
  registerSearch(server)
  registerDetails(server)
  registerFilters(server)
  return server
}

import { NextResponse } from 'next/server';

// The address of the MCP server, such as http://localhost:4000/api/mcp/catalog.
const MCP_SERVER_URL = process.env.MCP_SERVER_URL;
const FORWARDED_HEADERS = ['accept', 'content-type', 'mcp-protocol-version'];

export async function POST(request) {
  const headers = Object.fromEntries(
    FORWARDED_HEADERS.filter((name) => request.headers.has(name)).map((name) => [name, request.headers.get(name)]),
  );
  const upstream = await fetch(MCP_SERVER_URL, { method: 'POST', headers, body: await request.text() });
  return new Response(upstream.body, {
    status: upstream.status,
    headers: { 'content-type': upstream.headers.get('content-type') ?? 'application/json' },
  });
}

const methodNotAllowed = () => NextResponse.json(
  { error: 'Method not allowed' },
  { status: 405, headers: { Allow: 'POST' } },
);

export const GET = methodNotAllowed;
export const DELETE = methodNotAllowed;

export const runtime = 'nodejs';

// The kosher types the restaurant schema accepts.
const KOSHER_TYPES = Restaurant.schema.path('type').enumValues

const SEARCH_INPUT = {
  kosherType: z.enum(KOSHER_TYPES).optional(),
  features: z.array(z.enum(Object.keys(FEATURE_FIELDS))).optional()
}

const SEARCH_INPUT = {
  kosherType: z.enum(KOSHER_TYPES).optional()
    .describe('Bassari serves meat, Halavi serves dairy, Vegan serves neither, and "Bassari & Halavi" is the rare '
      + 'place with both a meat and a dairy kitchen. Leave it out when the visitor has no preference'),
  features: z.array(z.enum(Object.keys(FEATURE_FIELDS))).optional()
    .describe('Features every result must have; dateFriendly marks places suited to a shidduch date')
}

const registerSearch = (server) => server.registerTool('search_restaurants', {
  title: 'Search kosher restaurants',
  description: 'Search the kosher restaurants listed on TaamTaam in Israel and Miami. Translate the visitor\'s mood '
    + 'and needs into filters; call list_filters first to learn the accepted values. Send only the filters the '
    + 'visitor asked for, since each one narrows the results. Returns at most '
    + `${MAX_LIMIT} restaurants, best rated first, each with its page url. If nothing matches, relax a filter.`,
  inputSchema: SEARCH_INPUT,
  annotations: READ_ONLY
}, async (filters) => jsonResult(await catalog.searchRestaurants(filters)))

const textList = (description) => z.array(z.string().max(80)).max(10).optional().describe(description)

// Part of the search schema; the full one also holds the kashrut, style, feature and price filters.
const SEARCH_INPUT = {
  city: z.string().max(40).optional().describe('City slug from list_filters, such as telaviv or jerusalem'),
  cuisines: textList('Cuisines (any of), values from list_filters'),
  ambiances: textList('Ambiances (any of), values from list_filters, such as Romantic or Lively'),
  text: z.string().max(80).optional().describe('Words searched in the name, description and neighborhood'),
  limit: z.number().int().min(1).max(MAX_LIMIT).optional()
}

const registerDetails = (server) => server.registerTool('get_restaurant', {
  title: 'Restaurant details',
  description: 'Everything TaamTaam publishes about one restaurant: address, opening hours, review, FAQ, phone '
    + 'and booking link. Use the slug returned by search_restaurants.',
  inputSchema: {
    city: z.string().max(40).describe('slug.city from search_restaurants'),
    name: z.string().max(120).describe('slug.name from search_restaurants')
  },
  annotations: READ_ONLY
}, async (slug) => {
  const restaurant = await catalog.getRestaurant(slug)
  if (!restaurant) {
    return { isError: true, content: [{ type: 'text', text: 'No such restaurant' }] }
  }
  return jsonResult(restaurant)
})

export const SYSTEM_PROMPT = [
  'You are the restaurant guide of TaamTaam, a curated list of kosher restaurants in Israel and Miami.',
  'Recommend only restaurants returned by the tools. Call list_filters once to learn the accepted values, then',
  'search_restaurants with the filters that match the visitor\'s mood, occasion, city, kashrut and budget.',
  'When a search returns nothing, relax one filter and search again.',
  'Suggest three restaurants at most. For each, give its exact name as returned, and one sentence on why it',
  'fits. Ask one short question when the city or the meat or dairy choice is missing and matters.',
  'Answer in the visitor\'s language, briefly, in plain text.',
].join(' ');

const SEARCH_TOOL = 'search_restaurants';

function parseRestaurants(result) {
  try {
    const parsed = JSON.parse(result);
    return Array.isArray(parsed) ? parsed : [];
  } catch {
    return [];
  }
}

export function suggestedRestaurants(turn) {
  const answer = turn.answer.toLowerCase();
  const found = new Map();
  for (const { call, result } of turn.tools) {
    if (call.name !== SEARCH_TOOL || !result) {
      continue;
    }
    for (const restaurant of parseRestaurants(result)) {
      found.set(restaurant.id, restaurant);
    }
  }
  return [...found.values()]
    .map((restaurant) => ({ restaurant, position: answer.indexOf(restaurant.name.toLowerCase()) }))
    .filter(({ position }) => position >= 0)
    .sort((a, b) => a.position - b.position)
    .map(({ restaurant }) => restaurant);
}

import { useMemo } from 'react';
import { McpToolSource } from '@aiconnect/core';
import { useAiChat } from '@aiconnect/react';
import { MCP_PATH, SITE_NAME, SYSTEM_PROMPT } from '../constants/moodSearch';
import { suggestedRestaurants } from '../utils/suggestedRestaurants';

export default function useMoodSearch() {
  const tools = useMemo(() => new McpToolSource(MCP_PATH, SITE_NAME), []);
  const chat = useAiChat({ system: SYSTEM_PROMPT, tools });
  const turns = useMemo(
    () => chat.turns.map((turn) => ({ ...turn, restaurants: suggestedRestaurants(turn) })),
    [chat.turns],
  );
  return { ...chat, turns };
}