finmap-mcp 1.0.7 → 1.1.0

package/README.md

@@ -52,7 +52,7 @@ npx finmap-mcp
   "mcpServers": {
     "finmap": {
       "command": "npx",
-      "args": ["finmap-mcp"]
+      "args": ["-y", "finmap-mcp"]
     }
   }
 }

package/dist/core.js

@@ -12,6 +12,24 @@ const INFO = {
     issues: "https://github.com/finmap-org/mcp-server/issues",
     feedback: "contact@finmap.org",
 };
+const STOCK_EXCHANGES = [
+    "amex",
+    "nasdaq",
+    "nyse",
+    "us-all",
+    "lse",
+    "moex",
+    "bist",
+];
+const US_EXCHANGES = ["amex", "nasdaq", "nyse"];
+const SORT_FIELDS = [
+    "priceChangePct",
+    "marketCap",
+    "value",
+    "volume",
+    "numTrades",
+];
+const SORT_ORDERS = ["asc", "desc"];
 const INDICES = {
     EXCHANGE: 0,
     COUNTRY: 1,
@@ -46,61 +64,88 @@ const EXCHANGE_TO_COUNTRY_MAP = {
     moex: "russia",
     bist: "turkey",
 };
+function createResponse(data) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    };
+}
+function createErrorResponse(error) {
+    return createResponse(`ERROR: ${error instanceof Error ? error.message : String(error)}`);
+}
+function createCharts(exchange, date) {
+    return {
+        histogram: `${BASE_URL}/?chartType=histogram&dataType=marketcap&exchange=${exchange}`,
+        treemap: `${BASE_URL}/?chartType=treemap&dataType=marketcap&exchange=${exchange}${date ? `&date=${date}` : ""}`,
+    };
+}
+function calculateMatchScore(ticker, name, searchTerm) {
+    const tickerLower = ticker.toLowerCase();
+    const nameLower = name.toLowerCase();
+    if (tickerLower === searchTerm)
+        return 100;
+    if (tickerLower.startsWith(searchTerm))
+        return 90;
+    if (tickerLower.includes(searchTerm))
+        return 80;
+    if (nameLower.includes(searchTerm))
+        return 70;
+    return 0;
+}
 const EXCHANGE_INFO = {
     amex: {
         name: "American Stock Exchange",
         country: "United States",
+        currency: "USD",
         availableSince: "2024-12-09",
         updateFrequency: "Hourly (weekdays)",
     },
     nasdaq: {
         name: "NASDAQ Stock Market",
         country: "United States",
+        currency: "USD",
         availableSince: "2024-12-09",
         updateFrequency: "Hourly (weekdays)",
     },
     nyse: {
         name: "New York Stock Exchange",
         country: "United States",
+        currency: "USD",
         availableSince: "2024-12-09",
         updateFrequency: "Hourly (weekdays)",
     },
     "us-all": {
         name: "US Combined (AMEX + NASDAQ + NYSE)",
         country: "United States",
+        currency: "USD",
         availableSince: "2024-12-09",
         updateFrequency: "Hourly (weekdays)",
     },
     lse: {
         name: "London Stock Exchange",
         country: "United Kingdom",
+        currency: "GBP",
         availableSince: "2025-02-07",
         updateFrequency: "Hourly (weekdays)",
     },
     moex: {
         name: "Moscow Exchange",
         country: "Russia",
+        currency: "RUB",
         availableSince: "2011-12-19",
         updateFrequency: "Every 15 minutes (weekdays)",
     },
     bist: {
         name: "Borsa Istanbul",
         country: "Turkey",
+        currency: "TRY",
         availableSince: "2015-11-30",
-        updateFrequency: "Bi-monthly",
+        updateFrequency: "Every two months",
     },
 };
-const commonInputSchema = {
-    stockExchange: z
-        .enum(["amex", "nasdaq", "nyse", "us-all", "lse", "moex", "bist"])
-        .describe(`Stock exchange identifier:
-      amex - American Stock Exchange;
-      nasdaq - Nasdaq;
-      nyse - New York Stock Exchange;
-      us-all - AmEx, Nasdaq and NYSE combined;
-      lse - London Stock Exchange;
-      moex - Moscow Exchange;
-      bist - Borsa Istanbul (Turkish Stock Exchange)`),
+const exchangeSchema = z
+    .enum(STOCK_EXCHANGES)
+    .describe("Stock exchange: amex, nasdaq, nyse, us-all, lse, moex, bist");
+const dateSchema = {
     year: z.number().int().min(2012).optional(),
     month: z.number().int().min(1).max(12).optional(),
     day: z.number().int().min(1).max(31).optional(),
@@ -113,13 +158,17 @@ function buildDateString(year, month, day) {
     return `${y.toString()}/${m.toString().padStart(2, "0")}/${d.toString().padStart(2, "0")}`;
 }
 function validateAndFormatDate(dateString) {
-    const formattedDate = dateString.replaceAll("/", "-");
-    z.string().date().parse(formattedDate);
-    const dayOfWeek = new Date(formattedDate).getDay();
+    const date = dateString.replaceAll("/", "-");
+    z.string().date().parse(date);
+    const dayOfWeek = new Date(date).getDay();
     if (dayOfWeek === 0 || dayOfWeek === 6) {
         throw new Error("Data is only available for work days (Monday to Friday)");
     }
-    return formattedDate;
+    return date;
+}
+function getDate(year, month, day) {
+    const dateString = buildDateString(year, month, day);
+    return validateAndFormatDate(dateString);
 }
 async function fetchMarketData(stockExchange, formattedDate) {
     const country = EXCHANGE_TO_COUNTRY_MAP[stockExchange];
@@ -142,365 +191,352 @@ async function fetchSecurityInfo(exchange, ticker) {
     return data;
 }
 export function registerFinmapTools(server) {
-    server.registerResource("exchanges-info", "finmap://exchanges-info", {
-        title: "Stock exchanges information",
-        description: "Available stock exchanges with details about data availability and update frequency",
-        mimeType: "application/json",
+    server.registerTool("list_exchanges", {
+        title: "List exchanges",
+        description: "Return supported exchanges with IDs, names, country, currency, earliest available date, and update frequency.",
+        inputSchema: {},
     }, async () => {
-        return {
-            contents: [
-                {
-                    uri: "finmap://exchanges-info",
-                    text: JSON.stringify(EXCHANGE_INFO, null, 2),
-                },
-            ],
-        };
+        try {
+            const exchanges = Object.entries(EXCHANGE_INFO).map(([id, info]) => ({
+                id,
+                ...info,
+            }));
+            return createResponse({ info: INFO, exchanges });
+        }
+        catch (error) {
+            return createErrorResponse(error);
+        }
     });
-    server.registerTool("get-marketdata", {
-        title: "Get Marketdata",
-        description: "Get the market capitalization, volume, value and number of trades for the entire market and for each sector on a given date. If date is not provided, returns the latest available data",
-        inputSchema: commonInputSchema,
+    server.registerTool("list_sectors", {
+        title: "List sectors",
+        description: "List available business sectors for an exchange on a specific date, including item counts.",
+        inputSchema: { stockExchange: exchangeSchema, ...dateSchema },
     }, async ({ stockExchange, year, month, day, }) => {
         try {
-            const dateString = buildDateString(year, month, day);
-            const formattedDate = validateAndFormatDate(dateString);
+            const formattedDate = getDate(year, month, day);
+            const marketDataResponse = await fetchMarketData(stockExchange, formattedDate);
+            const sectorCounts = {};
+            marketDataResponse.securities.data.forEach((item) => {
+                if (item[INDICES.TYPE] !== "sector" && item[INDICES.SECTOR]) {
+                    sectorCounts[item[INDICES.SECTOR]] =
+                        (sectorCounts[item[INDICES.SECTOR]] || 0) + 1;
+                }
+            });
+            const sectors = Object.entries(sectorCounts).map(([name, count]) => ({
+                name,
+                count,
+            }));
+            return createResponse({
+                info: INFO,
+                date: formattedDate,
+                exchange: stockExchange.toUpperCase(),
+                currency: EXCHANGE_INFO[stockExchange].currency,
+                sectors,
+            });
+        }
+        catch (error) {
+            return createErrorResponse(error);
+        }
+    });
+    server.registerTool("list_tickers", {
+        title: "List tickers by sector",
+        description: "Return company tickers and names for an exchange on a specific date, grouped by sector.",
+        inputSchema: {
+            stockExchange: exchangeSchema,
+            ...dateSchema,
+            sector: z.string().optional().describe("Filter by specific sector"),
+            englishNames: z
+                .boolean()
+                .default(true)
+                .describe("Use English names if available"),
+        },
+    }, async ({ stockExchange, year, month, day, sector, englishNames, }) => {
+        try {
+            const formattedDate = getDate(year, month, day);
+            const marketDataResponse = await fetchMarketData(stockExchange, formattedDate);
+            const sectorGroups = {};
+            marketDataResponse.securities.data.forEach((item) => {
+                if (item[INDICES.TYPE] !== "sector" &&
+                    item[INDICES.SECTOR] &&
+                    (!sector || item[INDICES.SECTOR] === sector)) {
+                    const sectorName = item[INDICES.SECTOR];
+                    const ticker = item[INDICES.TICKER];
+                    const name = englishNames
+                        ? item[INDICES.NAME_ENG]
+                        : item[INDICES.NAME_ORIGINAL_SHORT] || item[INDICES.NAME_ENG];
+                    if (ticker && name) {
+                        if (!sectorGroups[sectorName])
+                            sectorGroups[sectorName] = [];
+                        sectorGroups[sectorName].push({ ticker, name });
+                    }
+                }
+            });
+            Object.values(sectorGroups).forEach((companies) => {
+                companies.sort((a, b) => a.ticker.localeCompare(b.ticker));
+            });
+            return createResponse({
+                info: INFO,
+                date: formattedDate,
+                exchange: stockExchange.toUpperCase(),
+                currency: EXCHANGE_INFO[stockExchange].currency,
+                sectors: sectorGroups,
+            });
+        }
+        catch (error) {
+            return createErrorResponse(error);
+        }
+    });
+    server.registerTool("search_companies", {
+        title: "Search companies",
+        description: "Find companies by partial name or ticker on an exchange and return best matches",
+        inputSchema: {
+            stockExchange: exchangeSchema,
+            ...dateSchema,
+            query: z
+                .string()
+                .describe("Search term (partial ticker or company name)"),
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(50)
+                .default(10)
+                .describe("Maximum results"),
+        },
+    }, async ({ stockExchange, year, month, day, query, limit, }) => {
+        try {
+            const formattedDate = getDate(year, month, day);
             const marketDataResponse = await fetchMarketData(stockExchange, formattedDate);
-            const sectorItems = marketDataResponse.securities.data.filter((securityItem) => securityItem[INDICES.TYPE] === "sector");
-            const result = {
+            const searchTerm = query.toLowerCase();
+            const matches = marketDataResponse.securities.data
+                .filter((item) => item[INDICES.TYPE] !== "sector" && item[INDICES.SECTOR])
+                .map((item) => ({
+                ticker: item[INDICES.TICKER],
+                name: item[INDICES.NAME_ENG],
+                sector: item[INDICES.SECTOR],
+                score: calculateMatchScore(item[INDICES.TICKER], item[INDICES.NAME_ENG], searchTerm),
+            }))
+                .filter((match) => match.score > 0)
+                .sort((a, b) => b.score - a.score)
+                .slice(0, limit);
+            return createResponse({
                 info: INFO,
-                charts: {
-                    histogram: `${BASE_URL}/?chartType=histogram&dataType=marketcap&exchange=${stockExchange}`,
-                    treemap: `${BASE_URL}/?chartType=treemap&dataType=marketcap&exchange=${stockExchange}&date=${formattedDate}`,
-                },
                 date: formattedDate,
                 exchange: stockExchange.toUpperCase(),
-                descriptions: {
-                    marketCap: "Market capitalization - total value of all shares outstanding",
-                    marketCapChangePct: "Percentage change in market capitalization from previous period",
-                    volume: "Trading volume - total number of shares traded",
-                    value: "Trading value - total monetary value of shares traded",
-                    numTrades: "Number of trades - total count of executed trades",
-                    itemsPerSector: "Number of items in the sector",
-                },
-                marketTotal: {},
-                sectors: [],
-            };
-            sectorItems.forEach((sectorItem) => {
+                currency: EXCHANGE_INFO[stockExchange].currency,
+                query,
+                matches,
+            });
+        }
+        catch (error) {
+            return createErrorResponse(error);
+        }
+    });
+    server.registerTool("get_market_overview", {
+        title: "Market overview",
+        description: "Get total market cap, volume, value, and performance for an exchange on a specific date with a sector breakdown.",
+        inputSchema: { stockExchange: exchangeSchema, ...dateSchema },
+    }, async ({ stockExchange, year, month, day, }) => {
+        try {
+            const formattedDate = getDate(year, month, day);
+            const marketDataResponse = await fetchMarketData(stockExchange, formattedDate);
+            const sectorItems = marketDataResponse.securities.data.filter((item) => item[INDICES.TYPE] === "sector");
+            let marketTotal = {};
+            const sectors = [];
+            sectorItems.forEach((item) => {
                 const sectorData = {
-                    name: sectorItem[INDICES.TICKER],
-                    marketCap: sectorItem[INDICES.MARKET_CAP],
-                    marketCapChangePct: sectorItem[INDICES.PRICE_CHANGE_PCT],
-                    volume: sectorItem[INDICES.VOLUME],
-                    value: sectorItem[INDICES.VALUE],
-                    numTrades: sectorItem[INDICES.NUM_TRADES],
-                    itemsPerSector: sectorItem[INDICES.ITEMS_PER_SECTOR],
+                    name: item[INDICES.TICKER],
+                    marketCap: item[INDICES.MARKET_CAP],
+                    marketCapChangePct: item[INDICES.PRICE_CHANGE_PCT],
+                    volume: item[INDICES.VOLUME],
+                    value: item[INDICES.VALUE],
+                    numTrades: item[INDICES.NUM_TRADES],
+                    itemsPerSector: item[INDICES.ITEMS_PER_SECTOR],
                 };
-                if (sectorItem[INDICES.SECTOR] === "") {
-                    result.marketTotal = sectorData;
+                if (item[INDICES.SECTOR] === "") {
+                    marketTotal = sectorData;
                 }
                 else {
-                    result.sectors.push(sectorData);
+                    sectors.push(sectorData);
                 }
             });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
+            return createResponse({
+                info: INFO,
+                charts: createCharts(stockExchange, formattedDate),
+                date: formattedDate,
+                exchange: stockExchange.toUpperCase(),
+                currency: EXCHANGE_INFO[stockExchange].currency,
+                marketTotal,
+                sectors,
+            });
         }
         catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `ERROR: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
+            return createErrorResponse(error);
         }
     });
-    server.registerTool("get-tickers", {
-        title: "Get Tickers",
-        description: "Get tickers and company names on a given date. If date is not provided, returns the latest available data",
+    server.registerTool("get_sectors_overview", {
+        title: "Sector performance",
+        description: "Get aggregated performance metrics by sector for an exchange on a specific date.",
         inputSchema: {
-            ...commonInputSchema,
-            englishNames: z
-                .boolean()
-                .default(true)
-                .optional()
-                .describe(`If false, returns the original company names instead of the English ones`),
+            stockExchange: exchangeSchema,
+            ...dateSchema,
             sector: z
                 .string()
                 .optional()
-                .describe(`If provided, filters the results to the specified sector`),
+                .describe("Get data for specific sector only"),
         },
-    }, async ({ stockExchange, year, month, day, englishNames, sector, }) => {
+    }, async ({ stockExchange, year, month, day, sector, }) => {
         try {
-            const dateString = buildDateString(year, month, day);
-            const formattedDate = validateAndFormatDate(dateString);
+            const formattedDate = getDate(year, month, day);
             const marketDataResponse = await fetchMarketData(stockExchange, formattedDate);
-            const tickersResult = {
+            const sectors = marketDataResponse.securities.data
+                .filter((item) => item[INDICES.TYPE] === "sector" && item[INDICES.SECTOR] !== "")
+                .filter((item) => !sector || item[INDICES.TICKER] === sector)
+                .map((item) => ({
+                name: item[INDICES.TICKER],
+                marketCap: item[INDICES.MARKET_CAP],
+                marketCapChangePct: item[INDICES.PRICE_CHANGE_PCT],
+                volume: item[INDICES.VOLUME],
+                value: item[INDICES.VALUE],
+                numTrades: item[INDICES.NUM_TRADES],
+                itemsPerSector: item[INDICES.ITEMS_PER_SECTOR],
+            }));
+            return createResponse({
+                info: INFO,
+                charts: createCharts(stockExchange, formattedDate),
                 date: formattedDate,
                 exchange: stockExchange.toUpperCase(),
-                sector: sector || "all",
-                englishNames: englishNames ?? true,
-                itemsPerSector: 0,
-                sectors: {},
-            };
-            const result = {
-                info: INFO,
-                charts: {
-                    histogram: `${BASE_URL}/?chartType=histogram&dataType=marketcap&exchange=${stockExchange}`,
-                    treemap: `${BASE_URL}/?chartType=treemap&dataType=marketcap&exchange=${stockExchange}&date=${formattedDate}`,
-                },
-                ...tickersResult,
-            };
-            const filteredSecurities = marketDataResponse.securities.data.filter((securityItem) => securityItem[INDICES.TYPE] !== "sector" &&
-                securityItem[INDICES.SECTOR] !== "" &&
-                (!sector || securityItem[INDICES.SECTOR] === sector));
-            const groupedBySector = filteredSecurities.reduce((accumulator, securityItem) => {
-                const sectorName = securityItem[INDICES.SECTOR];
-                if (!accumulator[sectorName])
-                    accumulator[sectorName] = [];
-                accumulator[sectorName].push(securityItem);
-                return accumulator;
-            }, {});
-            for (const [sectorName, sectorSecurities] of Object.entries(groupedBySector)) {
-                const validTickerPairs = sectorSecurities
-                    .map((securityItem) => {
-                    const ticker = securityItem[INDICES.TICKER];
-                    const companyName = englishNames
-                        ? securityItem[INDICES.NAME_ENG]
-                        : securityItem[INDICES.NAME_ORIGINAL_SHORT] ||
-                            securityItem[INDICES.NAME_ENG];
-                    return ticker && companyName
-                        ? [ticker, companyName]
-                        : null;
-                })
-                    .filter((entry) => entry !== null)
-                    .sort(([a], [b]) => a.localeCompare(b));
-                const tickersMap = Object.fromEntries(validTickerPairs);
-                if (Object.keys(tickersMap).length > 0) {
-                    result.sectors[sectorName] = {
-                        count: Object.keys(tickersMap).length,
-                        tickers: tickersMap,
-                    };
-                    result.itemsPerSector += Object.keys(tickersMap).length;
-                }
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
+                currency: EXCHANGE_INFO[stockExchange].currency,
+                sectors,
+            });
         }
         catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `ERROR: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
+            return createErrorResponse(error);
         }
     });
-    server.registerTool("get-marketdata-by-ticker", {
-        title: "Get Market Data by Ticker",
-        description: "Get market data for a specific ticker on a given date",
+    server.registerTool("get_stock_data", {
+        title: "Stock data by ticker",
+        description: "Get detailed market data for a specific ticker on an exchange and date, including price, change, volume, value, market cap, and trades.",
         inputSchema: {
-            ...commonInputSchema,
-            ticker: z
-                .string()
-                .describe("The ticker symbol to get market data for. Case-sensitive"),
+            stockExchange: exchangeSchema,
+            ...dateSchema,
+            ticker: z.string().describe("Stock ticker symbol (case-sensitive)"),
         },
     }, async ({ stockExchange, year, month, day, ticker, }) => {
         try {
-            const dateString = buildDateString(year, month, day);
-            const formattedDate = validateAndFormatDate(dateString);
+            const formattedDate = getDate(year, month, day);
             const marketDataResponse = await fetchMarketData(stockExchange, formattedDate);
-            const marketData = marketDataResponse.securities.data.find((securityItem) => securityItem[INDICES.TYPE] !== "sector" &&
-                securityItem[INDICES.TICKER] === ticker);
-            if (!marketData) {
+            const stockData = marketDataResponse.securities.data.find((item) => item[INDICES.TYPE] !== "sector" && item[INDICES.TICKER] === ticker);
+            if (!stockData) {
                 throw new Error(`Ticker ${ticker} not found on ${stockExchange} for date ${formattedDate}`);
             }
-            const result = {
+            return createResponse({
                 info: INFO,
-                charts: {
-                    histogram: `${BASE_URL}/?chartType=histogram&dataType=marketcap&exchange=${stockExchange}`,
-                    treemap: `${BASE_URL}/?chartType=treemap&dataType=marketcap&exchange=${stockExchange}&date=${formattedDate}`,
-                },
-                exchange: marketData[INDICES.EXCHANGE],
-                country: marketData[INDICES.COUNTRY],
-                type: marketData[INDICES.TYPE],
-                sector: marketData[INDICES.SECTOR],
-                industry: marketData[INDICES.INDUSTRY],
-                currencyId: marketData[INDICES.CURRENCY_ID],
-                ticker: marketData[INDICES.TICKER],
-                nameEng: marketData[INDICES.NAME_ENG],
-                nameEngShort: marketData[INDICES.NAME_ENG_SHORT],
-                nameOriginal: marketData[INDICES.NAME_ORIGINAL],
-                nameOriginalShort: marketData[INDICES.NAME_ORIGINAL_SHORT],
-                priceOpen: marketData[INDICES.PRICE_OPEN],
-                priceLastSale: marketData[INDICES.PRICE_LAST_SALE],
-                priceChangePct: marketData[INDICES.PRICE_CHANGE_PCT],
-                volume: marketData[INDICES.VOLUME],
-                value: marketData[INDICES.VALUE],
-                numTrades: marketData[INDICES.NUM_TRADES],
-                marketCap: marketData[INDICES.MARKET_CAP],
-                listedFrom: marketData[INDICES.LISTED_FROM],
-                listedTill: marketData[INDICES.LISTED_TILL],
-                wikiPageIdEng: marketData[INDICES.WIKI_PAGE_ID_ENG],
-                wikiPageIdOriginal: marketData[INDICES.WIKI_PAGE_ID_ORIGINAL],
-                itemsPerSector: marketData[INDICES.ITEMS_PER_SECTOR],
-            };
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
+                charts: createCharts(stockExchange, formattedDate),
+                exchange: stockData[INDICES.EXCHANGE],
+                country: stockData[INDICES.COUNTRY],
+                currency: EXCHANGE_INFO[stockExchange].currency,
+                sector: stockData[INDICES.SECTOR],
+                ticker: stockData[INDICES.TICKER],
+                nameEng: stockData[INDICES.NAME_ENG],
+                nameOriginal: stockData[INDICES.NAME_ORIGINAL],
+                priceOpen: stockData[INDICES.PRICE_OPEN],
+                priceLastSale: stockData[INDICES.PRICE_LAST_SALE],
+                priceChangePct: stockData[INDICES.PRICE_CHANGE_PCT],
+                volume: stockData[INDICES.VOLUME],
+                value: stockData[INDICES.VALUE],
+                numTrades: stockData[INDICES.NUM_TRADES],
+                marketCap: stockData[INDICES.MARKET_CAP],
+                listedFrom: stockData[INDICES.LISTED_FROM],
+                listedTill: stockData[INDICES.LISTED_TILL],
+            });
         }
         catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `ERROR: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
+            return createErrorResponse(error);
         }
     });
-    server.registerTool("get-top-marketdata", {
-        title: "Get Top Market Data",
-        description: "Get top N market data items sorted by specified field and order. Excludes sector-level data",
+    server.registerTool("rank_stocks", {
+        title: "Rank stocks",
+        description: "Rank stocks on an exchange by a chosen metric (marketCap, priceChangePct, volume, value, numTrades) for a specific date with order and limit.",
         inputSchema: {
-            ...commonInputSchema,
+            stockExchange: exchangeSchema,
+            ...dateSchema,
             sortBy: z
-                .enum(["priceChangePct", "marketCap", "value", "volume", "numTrades"])
-                .describe(`marketCap: Market capitalization - total value of all shares outstanding;
-              priceChangePct: Percentage change in share price from previous trading session;
-              volume: Trading volume - total number of shares traded;
-              value: Trading value - total monetary value of shares traded;
-              numTrades: Number of trades - total count of executed trades;
-              itemsPerSector: Number of items in the sector`),
-            order: z.enum(["asc", "desc"]).default("desc").describe("Sort order"),
+                .enum(SORT_FIELDS)
+                .describe("Sort by: marketCap, priceChangePct, volume, value, numTrades"),
+            order: z
+                .enum(SORT_ORDERS)
+                .default("desc")
+                .describe("Sort order: asc or desc"),
             limit: z
                 .number()
                 .int()
                 .min(1)
                 .max(500)
                 .default(10)
-                .describe("Number of items to return"),
+                .describe("Number of results"),
+            sector: z.string().optional().describe("Filter by specific sector"),
         },
-    }, async ({ stockExchange, year, month, day, sortBy, order, limit, }) => {
+    }, async ({ stockExchange, year, month, day, sortBy, order, limit, sector, }) => {
         try {
-            const dateString = buildDateString(year, month, day);
-            const formattedDate = validateAndFormatDate(dateString);
+            const formattedDate = getDate(year, month, day);
             const marketDataResponse = await fetchMarketData(stockExchange, formattedDate);
-            const filteredSecurities = marketDataResponse.securities.data
-                .filter((securityItem) => securityItem[INDICES.TYPE] !== "sector" &&
-                securityItem[INDICES.SECTOR] !== "")
-                .map((securityItem) => ({
-                ticker: securityItem[INDICES.TICKER],
-                name: securityItem[INDICES.NAME_ENG],
-                sector: securityItem[INDICES.SECTOR],
-                priceLastSale: securityItem[INDICES.PRICE_LAST_SALE],
-                priceChangePct: securityItem[INDICES.PRICE_CHANGE_PCT],
-                marketCap: securityItem[INDICES.MARKET_CAP],
-                volume: securityItem[INDICES.VOLUME],
-                value: securityItem[INDICES.VALUE],
-                numTrades: securityItem[INDICES.NUM_TRADES],
+            const stocks = marketDataResponse.securities.data
+                .filter((item) => item[INDICES.TYPE] !== "sector" && item[INDICES.SECTOR] !== "")
+                .filter((item) => !sector || item[INDICES.SECTOR] === sector)
+                .map((item) => ({
+                ticker: item[INDICES.TICKER],
+                name: item[INDICES.NAME_ENG],
+                sector: item[INDICES.SECTOR],
+                priceLastSale: item[INDICES.PRICE_LAST_SALE],
+                priceChangePct: item[INDICES.PRICE_CHANGE_PCT],
+                marketCap: item[INDICES.MARKET_CAP],
+                volume: item[INDICES.VOLUME],
+                value: item[INDICES.VALUE],
+                numTrades: item[INDICES.NUM_TRADES],
             }))
                 .sort((a, b) => {
-                const aVal = a[sortBy];
-                const bVal = b[sortBy];
+                const aVal = a[sortBy], bVal = b[sortBy];
                 return order === "desc" ? bVal - aVal : aVal - bVal;
             })
-                .slice(0, limit || 10);
-            const result = {
+                .slice(0, limit);
+            return createResponse({
                 info: INFO,
-                charts: {
-                    histogram: `${BASE_URL}/?chartType=histogram&dataType=marketcap&exchange=${stockExchange}`,
-                    treemap: `${BASE_URL}/?chartType=treemap&dataType=marketcap&exchange=${stockExchange}&date=${formattedDate}`,
-                },
+                charts: createCharts(stockExchange, formattedDate),
                 date: formattedDate,
                 exchange: stockExchange.toUpperCase(),
-                sortBy: sortBy,
-                order: order || "desc",
-                limit: limit || 10,
-                count: filteredSecurities.length,
-                filteredSecurities,
-            };
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
+                currency: EXCHANGE_INFO[stockExchange].currency,
+                sortBy,
+                order,
+                limit,
+                count: stocks.length,
+                stocks,
+            });
         }
         catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `ERROR: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
+            return createErrorResponse(error);
         }
     });
-    server.registerTool("get-company-info", {
-        title: "Get Company Description",
-        description: "Get detailed information for a US company by provided ticker (NASDAQ, NYSE, AMEX only)",
+    server.registerTool("get_company_profile", {
+        title: "Company profile (US)",
+        description: "Get business description, industry, and background for a US-listed company by ticker.",
         inputSchema: {
             exchange: z
-                .enum(["nasdaq", "nyse", "amex"])
-                .describe("US exchange identifier"),
-            ticker: z
-                .string()
-                .describe("The ticker symbol to get information for. Case-sensitive"),
+                .enum(US_EXCHANGES)
+                .describe("US exchange: amex, nasdaq, nyse"),
+            ticker: z.string().describe("Stock ticker symbol (case-sensitive)"),
         },
     }, async ({ exchange, ticker }) => {
         try {
             const securityInfo = await fetchSecurityInfo(exchange, ticker);
-            const result = {
+            return createResponse({
                 info: INFO,
-                charts: {
-                    histogram: `${BASE_URL}/?chartType=histogram&dataType=marketcap&exchange=${exchange}`,
-                    treemap: `${BASE_URL}/?chartType=treemap&dataType=marketcap&exchange=${exchange}`,
-                },
+                charts: createCharts(exchange),
                 ...securityInfo,
-            };
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
+            });
         }
         catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `ERROR: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
+            return createErrorResponse(error);
         }
     });
 }

package/dist/stdio-server.js

@@ -4,7 +4,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 const server = new McpServer({
     name: "finmap-mcp",
-    version: "1.0.0",
+    version: "1.1.0",
 });
 registerFinmapTools(server);
 const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "finmap-mcp",
-	"version": "1.0.7",
+	"version": "1.1.0",
 	"description": "MCP server providing financial market data from finmap.org",
 	"main": "./dist/stdio-server.js",
 	"type": "module",
@@ -73,16 +73,16 @@
 		"package": "npm run build:stdio && npm pack --pack-destination dist"
 	},
 	"dependencies": {
-		"@modelcontextprotocol/sdk": "1.17.3",
+		"@modelcontextprotocol/sdk": "1.17.4",
 		"agents": "^0.0.113",
 		"zod": "^3.25.76"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.2.0",
+		"@biomejs/biome": "^2.2.2",
 		"@types/node": "^24.3.0",
 		"rimraf": "^6.0.1",
-		"tsx": "^4.20.4",
+		"tsx": "^4.20.5",
 		"typescript": "5.9.2",
-		"wrangler": "^4.30.0"
+		"wrangler": "^4.33.1"
 	}
 }