@h1deya/langchain-mcp-tools 0.1.4 → 0.1.6

package/README.md

@@ -4,10 +4,10 @@ This package is intended to simplify the use of
 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/)
 server tools with LangChain.
 
-It contains a utility function `convertMcpToLangchainTools()`
-that initializes specified MCP servers,
-and returns [LangChain Tools](https://js.langchain.com/docs/how_to/tool_calling/)
-that wrap all the tools found in the MCP servers.
+It contains a utility function `convertMcpToLangchainTools()`.  
+This function handles parallel initialization of specified multiple MCP servers
+and converts their available tools into a list of
+[LangChain-compatible tools](https://js.langchain.com/docs/how_to/tool_calling/).
 
 ## Installation
 
@@ -17,8 +17,8 @@ npm i @h1deya/langchain-mcp-tools
 
 ## Quick Start
 
-`convertMcpToLangchainTools()` utility function accepts MCP server configuration
-that follows the same structure as
+`convertMcpToLangchainTools()` utility function accepts MCP server configurations
+that follow the same structure as
 [Claude for Desktop](https://modelcontextprotocol.io/quickstart/user),
 but only the contents of the `mcpServers` property,
 and is expressed as a JS Object, e.g.:
@@ -46,10 +46,10 @@ const { tools, cleanup } = await convertMcpToLangchainTools(mcpServers);
 
 The utility function initializes all specified MCP servers in parallel,
 and returns LangChain Tools (`tools: DynamicStructuredTool[]`)
-by gathering all the available MCP server tools,
+by gathering all available MCP server tools,
 and by wrapping them into [LangChain Tools](https://js.langchain.com/docs/how_to/tool_calling/).
 It also returns `cleanup` callback function
-which is used to close all the connections to the MCP servers when finished.
+to be invoked to close all MCP server sessions when finished.
 
 The returned tools can be used with LangChain, e.g.:
 

package/dist/langchain-mcp-tools.d.ts

@@ -10,11 +10,30 @@ export interface McpServersConfig {
 interface LogOptions {
     logLevel?: 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace';
 }
-export interface McpServerCleanupFunction {
+export interface McpServerCleanupFn {
     (): Promise<void>;
 }
+/**
+ * Initializes multiple MCP (Model Context Protocol) servers and converts them into LangChain tools.
+ * This function concurrently sets up all specified servers and aggregates their tools.
+ *
+ * @param configs - A mapping of server names to their respective configurations
+ * @param options - Optional logging configuration
+ *
+ * @returns A promise that resolves to:
+ *          - tools: Array of DynamicStructuredTool instances ready for use with LangChain
+ *          - cleanup: Function to properly terminate all server connections
+ *
+ * @throws McpInitializationError if any server fails to initialize
+ *
+ * @example
+ * const { tools, cleanup } = await convertMcpToLangchainTools({
+ *   filesystem: { command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', '.'] },
+ *   fetch: { command: 'uvx', args: ['mcp-server-fetch'] }
+ * });
+ */
 export declare function convertMcpToLangchainTools(configs: McpServersConfig, options?: LogOptions): Promise<{
     tools: DynamicStructuredTool[];
-    cleanup: McpServerCleanupFunction;
+    cleanup: McpServerCleanupFn;
 }>;
 export {};

package/dist/langchain-mcp-tools.js

@@ -5,17 +5,35 @@ import { DynamicStructuredTool } from '@langchain/core/tools';
 import { jsonSchemaToZod } from '@n8n/json-schema-to-zod';
 import { Logger } from './logger.js';
 // Custom error type for MCP server initialization failures
-class MCPInitializationError extends Error {
+class McpInitializationError extends Error {
     serverName;
     details;
     constructor(serverName, message, details) {
         super(message);
         this.serverName = serverName;
         this.details = details;
-        this.name = 'MCPInitializationError';
+        this.name = 'McpInitializationError';
     }
 }
-// Primary function to convert multiple MCP servers to LangChain tools
+/**
+ * Initializes multiple MCP (Model Context Protocol) servers and converts them into LangChain tools.
+ * This function concurrently sets up all specified servers and aggregates their tools.
+ *
+ * @param configs - A mapping of server names to their respective configurations
+ * @param options - Optional logging configuration
+ *
+ * @returns A promise that resolves to:
+ *          - tools: Array of DynamicStructuredTool instances ready for use with LangChain
+ *          - cleanup: Function to properly terminate all server connections
+ *
+ * @throws McpInitializationError if any server fails to initialize
+ *
+ * @example
+ * const { tools, cleanup } = await convertMcpToLangchainTools({
+ *   filesystem: { command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', '.'] },
+ *   fetch: { command: 'uvx', args: ['mcp-server-fetch'] }
+ * });
+ */
 export async function convertMcpToLangchainTools(configs, options) {
     const allTools = [];
     const cleanupCallbacks = [];
@@ -53,7 +71,24 @@ export async function convertMcpToLangchainTools(configs, options) {
     allTools.forEach((tool) => logger.debug(`- ${tool.name}`));
     return { tools: allTools, cleanup };
 }
-// Convert a single MCP server into LangChain tools
+/**
+ * Initializes a single MCP server and converts its capabilities into LangChain tools.
+ * Sets up a connection to the server, retrieves available tools, and creates corresponding
+ * LangChain tool instances.
+ *
+ * @param serverName - Unique identifier for the server instance
+ * @param config - Server configuration including command, arguments, and environment variables
+ * @param logger - Logger instance for recording operation details
+ *
+ * @returns A promise that resolves to:
+ *          - tools: Array of DynamicStructuredTool instances from this server
+ *          - cleanup: Function to properly terminate the server connection
+ *
+ * @throws McpInitializationError if server initialization fails
+ *         (includes connection errors, tool listing failures)
+ *
+ * @internal This function is meant to be called by convertMcpToLangchainTools
+ */
 async function convertSingleMcpToLangchainTools(serverName, config, logger) {
     let transport = null;
     let client = null;
@@ -87,7 +122,7 @@ async function convertSingleMcpToLangchainTools(serverName, config, logger) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             schema: jsonSchemaToZod(tool.inputSchema),
             func: async (input) => {
-                logger.info(`MCP Tool "${tool.name}" received input:`, input);
+                logger.info(`MCP tool "${serverName}"/"${tool.name}" received input:`, input);
                 // Execute tool call
                 const result = await client?.request({
                     method: "tools/call",
@@ -96,15 +131,16 @@ async function convertSingleMcpToLangchainTools(serverName, config, logger) {
                         arguments: input,
                     },
                 }, CallToolResultSchema);
-                const roughLength = JSON.stringify(result).length;
-                logger.info(`MCP Tool "${tool.name}" received result (length: ${roughLength})`);
-                logger.debug('result:', result);
-                const filteredResult = result?.content
-                    .filter(content => content.type === 'text')
-                    .map(content => content.text)
-                    .join('\n\n');
-                return filteredResult;
-                // return JSON.stringify(result.content);
+                const resultStringfied = JSON.stringify(result?.content);
+                const roughLength = resultStringfied.length;
+                logger.info(`MCP tool "${serverName}"/"${tool.name}" received result (length: ${roughLength})`);
+                logger.debug('result:', result?.content);
+                return resultStringfied;
+                // const filteredResult = result?.content
+                //   .filter(content => content.type === 'text')
+                //   .map(content => content.text)
+                //   .join('\n\n');
+                // return filteredResult;
             },
         })));
         logger.info(`MCP server "${serverName}": ${tools.length} tool(s) available:`);
@@ -112,7 +148,7 @@ async function convertSingleMcpToLangchainTools(serverName, config, logger) {
         async function cleanup() {
             if (transport) {
                 await transport.close();
-                logger.info(`MCP server "${serverName}": connection closed`);
+                logger.info(`MCP server "${serverName}": session closed`);
             }
         }
         return { tools, cleanup };
@@ -128,6 +164,6 @@ async function convertSingleMcpToLangchainTools(serverName, config, logger) {
                 logger.error(`Failed to cleanup during initialization error: ${cleanupError}`);
             }
         }
-        throw new MCPInitializationError(serverName, `Failed to initialize MCP server: ${error instanceof Error ? error.message : String(error)}`, error);
+        throw new McpInitializationError(serverName, `Failed to initialize MCP server: ${error instanceof Error ? error.message : String(error)}`, error);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h1deya/langchain-mcp-tools",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "MCP To LangChain Tools Conversion Utility",
   "license": "MIT",
   "keywords": [